?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Switched debug output to KPrintF(), because format specifiers come in RawDoFmt()...
[AROS.git] / rom / filesys / SFS / FS / filesystemmain.c
blob0996e194852620d8aa8074fda1a4500270852cc8
1 #include "asmsupport.h"
2
3 #include <exec/types.h>
4 #include <clib/macros.h> // MAX, MIN & ABS :-)
5 #include <devices/input.h>
6 #include <devices/inputevent.h>
7 #include <devices/timer.h>
8 #include <devices/trackdisk.h>
9 #include <dos/dos.h>
10 #include <dos/dosextens.h>
11 #include <dos/dostags.h>
12 #include <dos/exall.h>
13 #include <dos/filehandler.h>
14 #include <dos/notify.h>
15 #include <exec/errors.h>
16 #include <exec/interrupts.h>
17 #include <exec/io.h>
18 #include <exec/lists.h>
19 #include <exec/memory.h>
20 #include <exec/nodes.h>
21 #include <exec/resident.h>
22 #include <libraries/iffparse.h>
23 #include <resources/filesysres.h>
24 #include <proto/dos.h>
25 #include <proto/exec.h>
26 #include <proto/intuition.h>
27 #include <proto/timer.h>
28 #include <proto/utility.h>
29 /*
30 #define DEBUG 1
31 #define DEBUGCODE
32 */
33 #include <math.h>
34
35 #include "sysdep.h"
36 #include "fs.h"
37 #include "adminspaces.h"
38 #include "bitmap.h"
39 #include "btreenodes.h"
40 #include "locks.h"
41 #include "nodes.h"
42 #include "objects.h"
43 #include "transactions.h"
44
45 #include "adminspaces_protos.h"
46 #include "bitmap_protos.h"
47 #include "btreenodes_protos.h"
48 #include "cachebuffers_protos.h"
49 #include "debug.h"
50 #include "locks_protos.h"
51 #include "nodes_protos.h"
52 #include "objects_protos.h"
53 #include "packets.h"
54 #include "query.h"
55 #include "support_protos.h"
56 #include "transactions_protos.h"
57 #include "req_protos.h"
58
59 #include <string.h>
60
61 #include "cachedio_protos.h"
62 #include "deviceio_protos.h"
63
64 static LONG fillgap(BLCK key);
65 LONG step(void);
66
67 #define BNODE
68
69 #define BITMAPFILL 0xFFFFFFFF /* should be 0xFFFFFFFF ! Careful.. admin containers are 32 blocks! */
70
71 /* defines: */
72
73 #define BLCKFACCURACY (5) /* 2^5 = 32 */
74
75 #define TIMEOUT (1) /* Timeout in seconds */
76 #define FLUSHTIMEOUT (20) /* Flush timeout in seconds */
77
78 #define ID_BUSY AROS_LONG2BE(MAKE_ID('B','U','S','Y'))
79
80 /* Our own usage of NotifyRequest private data */
81 #define nr_Next nr_Reserved[2]
82 #define nr_Prev nr_Reserved[3]
83
84 /* structs */
85 #define SFSM_ADD_VOLUMENODE (1)
86 #define SFSM_REMOVE_VOLUMENODE (2)
87
88 struct SFSMessage {
89 struct Message msg;
90 ULONG command;
91 IPTR data;
92 LONG errorcode;
93 };
94
95 struct DefragmentStep {
96 ULONG id; // id of the step ("MOVE", "DONE" or 0)
97 ULONG length; // length in longwords (can be 0)
98 ULONG data[0]; // size of this array is determined by length.
99 };
100
101
102 /* global variables */
103
104 #include "globals.h"
105
106 #ifndef __AROS__
107 struct SFSBase *globals=NULL;
108 #endif
109
110 void initGlobals()
111 {
112 globals->is_LittleEndian = FALSE;
113 globals->inhibitnestcounter = 0;
114 globals->block_defragptr = 2;
115 globals->is_casesensitive = FALSE;
116 globals->has_recycled = TRUE;
117 globals->locklist = NULL;
118 globals->notifyrequests = NULL;
119 globals->activitytimeractive = FALSE;
120 globals->pendingchanges = FALSE;
121 globals->timerreset = FALSE;
122 globals->max_name_length = MAX_NAME_LENGTH;
123 globals->activity_timeout = FLUSHTIMEOUT;
124 globals->inactivity_timeout = TIMEOUT;
125 globals->retries = MAX_RETRIES;
126 globals->scsidirect = FALSE;
127 globals->does64bit = FALSE;
128 globals->newstyledevice = FALSE;
129 globals->deviceopened = FALSE;
130 globals->msgport = NULL;
131 globals->ioreq = NULL;
132 globals->ioreq2 = NULL;
133 globals->ioreqchangeint = NULL;
134 globals->cmdread = CMD_READ;
135 globals->cmdwrite = CMD_WRITE;
136 globals->blocks_maxtransfer = 1048576;
137 globals->mask_mask = -1;
138 globals->bufmemtype = MEMF_PUBLIC;
139 globals->transactionpool = 0;
140 globals->compressbuffer = 0;
141 globals->transactionnestcount = 0;
142 globals->iocache_lruhead = NULL;
143 globals->iocache_lines = 8;
144 globals->iocache_copyback = TRUE;
145 globals->iocache_readonwrite = FALSE;
146 globals->templockedobjectnode = 0;
147 globals->internalrename = FALSE;
148 globals->defrag_maxfilestoscan = 512;
149 globals->debugreqs=TRUE;
150
151 globals->mask_debug = 0xffff;
152 }
153
154 /* Prototypes */
155
156 static struct DosPacket *getpacket(struct Process *);
157 static struct DosPacket *waitpacket(struct Process *);
158 static void returnpacket(SIPTR,LONG);
159 static void sdlhtask(void);
160
161 /* Prototypes of cachebuffer related functions */
162
163 LONG readcachebuffercheck(struct CacheBuffer **,ULONG,ULONG);
164 void outputcachebuffer(struct CacheBuffer *cb);
165
166 /* Prototypes of node related functions */
167
168 LONG deleteextents(ULONG key);
169 static LONG findextentbnode(ULONG key,struct CacheBuffer **returned_cb,struct fsExtentBNode **returned_bnode);
170 static LONG createextentbnode(ULONG key,struct CacheBuffer **returned_cb,struct fsExtentBNode **returned_bnode);
171
172 /* Prototypes of debug functions */
173
174 ULONG calcchecksum(void);
175 void checksum(void);
176
177 /* Misc prototypes */
178
179 void starttimeout(void);
180 LONG flushcaches(void);
181 void invalidatecaches(void);
182
183 BOOL freeupspace(void);
184
185 BOOL checkchecksum(struct CacheBuffer *);
186 void setchecksum(struct CacheBuffer *);
187
188 void checknotifyforobject(struct CacheBuffer *cb,struct fsObject *o,UBYTE notifyparent);
189 void checknotifyforpath(UBYTE *path,UBYTE notifyparent);
190 void notify(struct NotifyRequest *nr);
191 UBYTE *fullpath(struct CacheBuffer *cbstart,struct fsObject *o);
192
193 LONG initdisk(void);
194 static void deinitdisk(void);
195
196 LONG handlesimplepackets(struct DosPacket *packet);
197 static LONG dumppackets(struct DosPacket *packet,LONG);
198 #ifdef DEBUGCODE
199 static void dumppacket(void);
200 #endif
201 static void actioncurrentvolume(struct DosPacket *);
202 static void actionsamelock(struct DosPacket *);
203 static void actiondiskinfo(struct DosPacket *);
204 static void fillinfodata(struct InfoData *);
205 static void fillfib(struct FileInfoBlock *,struct fsObject *);
206 static void diskchangenotify(ULONG class);
207
208 /* Prototypes of high-level filesystem functions */
209
210 LONG setfilesize(struct ExtFileLock *lock,ULONG bytes);
211 static LONG seek(struct ExtFileLock *lock,ULONG offset);
212 LONG seektocurrent(struct ExtFileLock *lock);
213 LONG seekextent(struct ExtFileLock *lock,ULONG offset,struct CacheBuffer **returned_cb,struct fsExtentBNode **returned_ebn,ULONG *returned_extentoffset);
214 void seekforward(struct ExtFileLock *lock, UWORD ebn_blocks, BLCK ebn_next, ULONG bytestoseek);
215 LONG writetofile(struct ExtFileLock *lock, UBYTE *buffer, ULONG bytestowrite);
216
217 static LONG extendblocksinfile(struct ExtFileLock *lock,ULONG blocks);
218 static LONG addblocks(UWORD blocks, BLCK newspace, NODE objectnode, BLCK *io_lastextentbnode);
219 LONG deletefileslowly(struct CacheBuffer *cbobject, struct fsObject *o);
220
221 void mainloop(void);
222
223 /* ASM prototypes */
224
225 #define MAJOR_VERSION (1)
226 #define MINOR_VERSION (84)
227
228 #ifdef __GNUC__
229 const char ver_version[]="\0$VER: " PROGRAMNAMEVER " 1.84 (" ADATE ")\r\n";
230 #else
231 static const char ver_version[]={"\0$VER: " PROGRAMNAMEVER " 1.84 " __AMIGADATE__ "\r\n"};
232 #endif
233
234 #ifdef __AROS__
235 /* AROS builds in a 'struct Resident' automatically
236 */
237 #else
238 /* ROMTag is useful for C:Version. */
239 #define res_Init NULL
240
241 const struct Resident resident =
242 {
243 RTC_MATCHWORD,
244 &resident,
245 (APTR)&resident + sizeof(struct Resident),
246 RTF_COLDSTART,
247 MAJOR_VERSION,
248 0,
249 -81,
250 PROGRAMNAME,
251 &ver_version[7],
252 res_Init
253 };
254 #endif
255
256 /* Main */
257
258 #ifndef __AROS__
259 extern const RESBASE;
260 extern const RESLEN;
261 extern const _LinkerDB;
262 extern const NEWDATAL;
263 #endif
264
265 LONG mainprogram(struct ExecBase *);
266
267 #ifndef __AROS__
268 #undef SysBase
269 #endif
270
271 #ifndef __AROS__
272 LONG __saveds trampoline(void)
273 {
274 struct ExecBase *sBase = (*((struct ExecBase **)4));
275
276 return mainprogram(sBase);
277 }
278
279 LONG start(void)
280 {
281 return(STACKSWAP(4096, trampoline));
282 /* if(STACKSWAP()==0) {
283 return(ERROR_NO_FREE_STORE);
284 }
285
286 return(mainprogram()); */
287 }
288 #endif
289
290 void request2(UBYTE *text);
291
292 // #define STARTDEBUG
293
294 LONG mainprogram(struct ExecBase *SysBase)
295 {
296 #ifndef __AROS__
297 ULONG reslen;
298 APTR old_a4;
299 APTR newdata;
300 #endif
301
302 D(bug("[SFS] Filesystem main\n"));
303
304 globals = AllocMem(sizeof(struct SFSBase), MEMF_PUBLIC | MEMF_CLEAR);
305 #ifndef __AROS__
306 globals->sysBase = SysBase;
307 #endif
308 initGlobals();
309
310 #ifndef __AROS__
311 #undef SysBase
312 #define SysBase (globals->sysBase)
313
314 old_a4=(APTR)getreg(REG_A4);
315 reslen=((ULONG)&RESLEN-(ULONG)old_a4)+64;
316
317 newdata=AllocMem(reslen,MEMF_CLEAR|MEMF_PUBLIC);
318
319 CopyMem(old_a4,newdata,*(((ULONG *)old_a4)-2));
320
321 putreg(REG_A4,(LONG)newdata);
322 #endif
323
324 if((DOSBase=(struct DosLibrary *)OpenLibrary("dos.library",37))!=0) {
325 D(bug("[SFS] DOSBase = %p\n", DOSBase));
326
327 globals->mytask=(struct Process *)FindTask(0);
328 D(bug("[SFS] mytask = %p\n", globals->mytask));
329
330 globals->packet=waitpacket(globals->mytask);
331 D(bug("[SFS] packet = %p\n", globals->packet));
332
333 globals->devnode=(struct DeviceNode *)BADDR(globals->packet->dp_Arg3);
334 globals->devnode->dn_Task=&globals->mytask->pr_MsgPort;
335 globals->startupmsg=BADDR(globals->devnode->dn_Startup);
336 D(bug("[SFS] devnode = %p\n", globals->devnode));
337 D(bug("[SFS] startupmsg = %p\n", globals->startupmsg));
338
339 if(initcachebuffers()==0) {
340
341 if((IntuitionBase=(APTR)OpenLibrary("intuition.library",37))!=0) {
342
343 #ifdef STARTDEBUG
344 dreq("(1) Filesystem initializing...");
345 #endif
346
347 if((UtilityBase=(APTR)OpenLibrary("utility.library",37))!=0) {
348
349 /* Create a msgport and iorequest for opening timer.device */
350
351 if((globals->msgportnotify=CreateMsgPort())!=0) {
352 if((globals->msgporttimer=CreateMsgPort())!=0) {
353 if((globals->msgportflushtimer=CreateMsgPort())!=0) {
354 if((globals->inactivitytimer_ioreq=(struct timerequest *)CreateIORequest(globals->msgporttimer, sizeof(struct timerequest)))!=0) {
355 if((globals->activitytimer_ioreq=(struct timerequest *)CreateIORequest(globals->msgportflushtimer, sizeof(struct timerequest)))!=0) {
356
357 #ifdef STARTDEBUG
358 dreq("(2) Message ports and iorequests created");
359 #endif
360
361 if(OpenDevice("timer.device",UNIT_VBLANK,&globals->inactivitytimer_ioreq->tr_node,0)==0) {
362 if(OpenDevice("timer.device",UNIT_VBLANK,&globals->activitytimer_ioreq->tr_node,0)==0) {
363
364 globals->dosenvec=(struct DosEnvec *)BADDR(globals->startupmsg->fssm_Environ);
365
366 globals->timerBase=(struct Device *)globals->inactivitytimer_ioreq->tr_node.io_Device;
367
368 /* Create a msgport and iorequest for opening the filesystem device */
369
370 initlist((struct List *)&globals->globalhandles);
371
372 #ifdef STARTDEBUG
373 dreq("(3) Timer.device opened");
374 #endif
375
376 if(initcachedio(AROS_BSTR_ADDR(globals->startupmsg->fssm_Device), globals->startupmsg->fssm_Unit, globals->startupmsg->fssm_Flags, globals->dosenvec)==0) {
377 #ifdef STARTDEBUG
378 dreq("(4) Cached IO layer started");
379 #endif
380
381 globals->shifts_block32=globals->shifts_block-BLCKFACCURACY;
382
383 globals->mask_block32=(1<<globals->shifts_block32)-1;
384 globals->blocks_inbitmap=(globals->bytes_block-sizeof(struct fsBitmap))<<3; /* must be a multiple of 32 !! */
385 globals->blocks_bitmap=(globals->blocks_total+globals->blocks_inbitmap-1)/globals->blocks_inbitmap;
386 globals->blocks_admin=32;
387
388 globals->blocks_reserved_start=MAX(globals->dosenvec->de_Reserved,1);
389 globals->blocks_reserved_end=MAX(globals->dosenvec->de_PreAlloc,1);
390
391 {
392 ULONG blocks512, reserve;
393
394 blocks512=globals->blocks_total<<(globals->shifts_block-9);
395 reserve=SQRT(blocks512);
396 reserve=(reserve<<2) + reserve;
397
398 if(reserve > blocks512/100) { // Do not use more than 1% of the disk.
399 reserve = blocks512/100;
400 }
401
402 if(reserve < globals->blocks_admin) { // Use atleast 32 blocks, even if it is more than 1%.
403 reserve = globals->blocks_admin;
404 if(reserve > globals->blocks_total>>1) {
405 reserve = 0;
406 }
407 }
408
409 globals->block_rovingblockptr=globals->blocks_reserved_start + globals->blocks_admin + globals->blocks_bitmap + reserve;
410
411 _DEBUG(("RovingBlockPtr = %ld, reserve = %ld\n", globals->block_rovingblockptr, reserve));
412
413 // block_rovingblockptr=0;
414 }
415
416 globals->mask_debug=0x00000000;
417
418 globals->node_containers=(globals->bytes_block-sizeof(struct fsNodeContainer))/sizeof(BLCKn);
419
420 addchangeint((struct Task *)globals->mytask, 1<<globals->mytask->pr_MsgPort.mp_SigBit);
421
422 _DEBUG(("Initializing transactions\n"));
423
424 if(inittransactions()==0) {
425
426 #ifdef STARTDEBUG
427 dreq("(5) Transaction layer started");
428 #endif
429
430 if(addcachebuffers(globals->dosenvec->de_NumBuffers)==0) {
431
432 #ifdef STARTDEBUG
433 dreq("(6) Filesystem started succesfully!");
434 #endif
435
436 /* return startup-packet, the handler runs now */
437
438 _DEBUG(("Filesystem started! Volumenode = %ld\n",globals->volumenode));
439 _DEBUG(("Mountlist entry says: Allocate %ld buffers of memtype 0x%08lx\n",globals->dosenvec->de_NumBuffers,globals->dosenvec->de_BufMemType));
440
441 // returnpacket(DOSTRUE,0); // Sep 19 1999: Moved down again.
442
443 _DEBUG(("CreateNewProc..."));
444
445 const struct TagItem tags[]=
446 {
447 {NP_Entry , (IPTR)sdlhtask },
448 {NP_Name , (IPTR)"SFS DosList handler"},
449 {NP_Priority , 19 },
450 {TAG_DONE , 0 }
451 };
452
453 if(CreateNewProc(tags)!=0) {
454
455 _DEBUG(("ok\n"));
456
457 while((globals->sdlhport=FindPort("SFS DosList handler"))==0) {
458 Delay(2);
459 }
460
461 if(isdiskpresent()!=FALSE) {
462 #ifdef STARTDEBUG
463 dreq("There is a disk present.");
464 #endif
465
466 initdisk();
467 }
468 else {
469 #ifdef STARTDEBUG
470 dreq("No disk inserted.");
471 #endif
472
473 globals->disktype=ID_NO_DISK_PRESENT;
474 }
475
476 returnpacket(DOSTRUE,0); // Jul 4 1999: Moved up...
477
478 #ifdef STARTDEBUG
479 dreq("(7) Informed DOS about the new partition!");
480 #endif
481
482 mainloop();
483 }
484 }
485
486 cleanuptransactions();
487 }
488
489 removechangeint();
490 cleanupcachedio();
491 }
492 CloseDevice(&globals->activitytimer_ioreq->tr_node);
493 }
494 CloseDevice(&globals->inactivitytimer_ioreq->tr_node);
495 }
496 DeleteIORequest((struct IORequest *)globals->activitytimer_ioreq);
497 }
498 DeleteIORequest((struct IORequest *)globals->inactivitytimer_ioreq);
499 }
500 DeleteMsgPort(globals->msgportflushtimer);
501 }
502 DeleteMsgPort(globals->msgporttimer);
503 }
504 DeleteMsgPort(globals->msgportnotify);
505 }
506 CloseLibrary((struct Library *)UtilityBase);
507 }
508
509 #ifdef STARTDEBUG
510 dreq("Filesystem failed.. exiting.");
511 #endif
512
513 CloseLibrary((struct Library *)IntuitionBase);
514 }
515 }
516
517 _DEBUG(("Returning startup packet with DOSFALSE\n"));
518
519 returnpacket(DOSFALSE,ERROR_NO_FREE_STORE);
520
521 CloseLibrary((struct Library *)DOSBase);
522 }
523
524 FreeMem(globals, sizeof(struct SFSBase));
525 _DEBUG(("Exiting filesystem\n"));
526
527 return(ERROR_NO_FREE_STORE);
528 }
529
530
531 void mainloop(void) {
532 ULONG signalbits;
533 struct MsgPort *msgportpackets;
534 struct Message *msg;
535
536 msgportpackets=&globals->mytask->pr_MsgPort; /* get port of our process */
537 signalbits=1<<msgportpackets->mp_SigBit;
538 signalbits|=1<<globals->msgporttimer->mp_SigBit;
539 signalbits|=1<<globals->msgportnotify->mp_SigBit;
540 signalbits|=1<<globals->msgportflushtimer->mp_SigBit;
541
542 #ifdef STARTDEBUG
543 dreq("Entering packet loop.");
544 #endif
545
546 for(;;) {
547
548 Wait(signalbits);
549
550 do {
551 while((msg=GetMsg(globals->msgportflushtimer))!=0) {
552 _TDEBUG(("mainloop: activity timeout -> flushed transaction\n"));
553 flushtransaction();
554 globals->activitytimeractive=FALSE;
555 }
556
557 while((msg=GetMsg(globals->msgporttimer))!=0) {
558 if(globals->timerreset==TRUE) {
559 /* There was another request during the timeout/2 period, so we extend the timeout a bit longer. */
560 globals->pendingchanges=FALSE;
561 starttimeout();
562 }
563 else {
564 _TDEBUG(("mainloop: inactivity timeout -> flushed transaction\n"));
565 flushcaches();
566 globals->pendingchanges=FALSE;
567 }
568 }
569
570 while((msg=GetMsg(globals->msgportnotify))!=0) {
571 FreeMem(msg,sizeof(struct NotifyMessage));
572 }
573
574 if(getchange()!=0) {
575
576 /* The disk was inserted or removed! */
577
578 _DEBUG(("mainloop: disk inserted or removed\n"));
579
580 if(isdiskpresent()==FALSE) {
581 /* Disk was removed */
582
583 globals->disktype=ID_NO_DISK_PRESENT; /* Must be put before deinitdisk() */
584 deinitdisk();
585 }
586 else {
587 /* Disk was inserted */
588
589 initdisk();
590 }
591 }
592
593 if((msg=GetMsg(msgportpackets))!=0) {
594
595
596 // diskstate=writeprotection(); /* Don't do this too often!! It takes LOADS of time for scsi.device. */
597
598
599 #ifdef CHECKCODE_SLOW
600 {
601 struct CacheBuffer *cb;
602
603 cb=(struct CacheBuffer *)cblrulist.mlh_Head;
604
605 while(cb->node.mln_Succ!=0) {
606 if(cb->locked!=0) {
607 request(PROGRAMNAME " request","%s\n"\
608 "mainloop: There was a locked CacheBuffer (lockcount = %ld, block = %ld, type = 0x%08lx)!\n"\
609 "Nothing bad will happen, but let the author know.\n",
610 "Ok",AROS_BSTR_ADDR(devnode->dn_Name), cb->locked, cb->blckno, *((ULONG *)cb->data));
611
612
613 cb->locked=0; /* Nothing remains locked */
614 }
615
616 cb=(struct CacheBuffer *)(cb->node.mln_Succ);
617 }
618 }
619 #endif
620
621
622 globals->packet=(struct DosPacket *)msg->mn_Node.ln_Name;
623
624 #ifdef STARTDEBUG
625 dreq("Received packet 0x%08lx, %ld.",globals->packet,globals->packet->dp_Type);
626 #endif
627
628 switch(globals->packet->dp_Type) {
629 case ACTION_SFS_SET:
630 {
631 struct TagItem *taglist=(struct TagItem *)globals->packet->dp_Arg1;
632 struct TagItem *tag;
633
634 while((tag=NextTagItem(&taglist))!=NULL) {
635 LONG data=tag->ti_Data;
636
637 switch(tag->ti_Tag) {
638 case ASS_MAX_NAME_LENGTH:
639 if(data >= 30 && data <= 100) {
640 globals->max_name_length=data;
641 }
642 break;
643 case ASS_ACTIVITY_FLUSH_TIMEOUT:
644 if(data >= 5 && data <= 120) {
645 globals->activity_timeout=data;
646 }
647 break;
648 case ASS_INACTIVITY_FLUSH_TIMEOUT:
649 if(data >= 1 && data <= 5) {
650 globals->inactivity_timeout=data;
651 }
652 break;
653 }
654 }
655
656 returnpacket(DOSTRUE,0);
657 }
658 break;
659 case ACTION_SFS_QUERY:
660 {
661 struct TagItem *taglist=(struct TagItem *)globals->packet->dp_Arg1;
662 struct TagItem *tag;
663
664 while((tag=NextTagItem(&taglist)))
665 {
666 switch(tag->ti_Tag)
667 {
668 case ASQ_START_BYTEH:
669 tag->ti_Data = globals->byte_low >> 32;
670 break;
671
672 case ASQ_START_BYTEL:
673 /*
674 * Explicitly cast to ULONG here because on 64 bits
675 * ti_Data is 64-bit wide, and this can confuse programs.
676 */
677 tag->ti_Data = (ULONG)globals->byte_low;
678 break;
679
680 case ASQ_END_BYTEH:
681 tag->ti_Data = globals->byte_high >> 32;
682 break;
683
684 case ASQ_END_BYTEL:
685 tag->ti_Data = (ULONG)globals->byte_high;
686 break;
687
688 case ASQ_DEVICE_API:
689 tag->ti_Data=deviceapiused();
690 break;
691 case ASQ_BLOCK_SIZE:
692 tag->ti_Data=globals->bytes_block;
693 break;
694 case ASQ_TOTAL_BLOCKS:
695 tag->ti_Data=globals->blocks_total;
696 break;
697 case ASQ_ROOTBLOCK:
698 tag->ti_Data=globals->block_root;
699 break;
700 case ASQ_ROOTBLOCK_OBJECTNODES:
701 tag->ti_Data=globals->block_objectnoderoot;
702 break;
703 case ASQ_ROOTBLOCK_EXTENTS:
704 tag->ti_Data=globals->block_extentbnoderoot;
705 break;
706 case ASQ_FIRST_BITMAP_BLOCK:
707 tag->ti_Data=globals->block_bitmapbase;
708 break;
709 case ASQ_FIRST_ADMINSPACE:
710 tag->ti_Data=globals->block_adminspace;
711 break;
712 case ASQ_CACHE_LINES:
713 tag->ti_Data=queryiocache_lines();
714 break;
715 case ASQ_CACHE_READAHEADSIZE:
716 tag->ti_Data=queryiocache_readaheadsize();
717 break;
718 case ASQ_CACHE_MODE:
719 tag->ti_Data=queryiocache_copyback();
720 break;
721 case ASQ_CACHE_BUFFERS:
722 tag->ti_Data=globals->totalbuffers;
723 break;
724 case ASQ_CACHE_ACCESSES:
725 tag->ti_Data=globals->statistics.cache_accesses;
726 break;
727 case ASQ_CACHE_MISSES:
728 tag->ti_Data=globals->statistics.cache_misses;
729 break;
730 case ASQ_OPERATIONS_DECODED:
731 tag->ti_Data=globals->statistics.cache_operationdecode;
732 break;
733 case ASQ_EMPTY_OPERATIONS_DECODED:
734 tag->ti_Data=globals->statistics.cache_emptyoperationdecode;
735 break;
736 case ASQ_IS_CASESENSITIVE:
737 tag->ti_Data=globals->is_casesensitive;
738 break;
739 case ASQ_HAS_RECYCLED:
740 tag->ti_Data=globals->has_recycled;
741 break;
742 case ASQ_VERSION:
743 tag->ti_Data=MAJOR_VERSION * 65536 + MINOR_VERSION;
744 break;
745 case ASQ_MAX_NAME_LENGTH:
746 tag->ti_Data=globals->max_name_length;
747 break;
748 case ASQ_ACTIVITY_FLUSH_TIMEOUT:
749 tag->ti_Data=globals->activity_timeout;
750 break;
751 case ASQ_INACTIVITY_FLUSH_TIMEOUT:
752 tag->ti_Data=globals->inactivity_timeout;
753 break;
754 }
755 }
756
757 returnpacket(DOSTRUE,0);
758 }
759 break;
760 case ACTION_SET_DEBUG:
761 _DEBUG(("New debug level set to 0x%08lx!\n",globals->packet->dp_Arg1));
762 {
763 globals->mask_debug=globals->packet->dp_Arg1;
764
765 returnpacket(DOSTRUE,0);
766 }
767 break;
768 case ACTION_SET_CACHE:
769 _DEBUG(("ACTION_SET_CACHE\n"));
770 {
771 LONG errorcode;
772
773 if((errorcode=setiocache(globals->packet->dp_Arg1, globals->packet->dp_Arg2, globals->packet->dp_Arg3 & 1))!=0) {
774 returnpacket(DOSFALSE, errorcode);
775 }
776 else {
777 returnpacket(DOSTRUE, 0);
778 }
779 }
780
781 break;
782 case ACTION_SFS_FORMAT:
783 case ACTION_FORMAT:
784 _DEBUG(("ACTION_FORMAT\n"));
785
786 {
787 struct CacheBuffer *cb;
788 ULONG currentdate;
789 BLCK block_recycled;
790 LONG errorcode=0;
791
792 UBYTE *name=0;
793 UBYTE *recycledname=".recycled";
794 BYTE casesensitive=FALSE;
795 BYTE norecycled=FALSE;
796 BYTE showrecycled=FALSE;
797 currentdate=getdate();
798
799 if(globals->packet->dp_Type==ACTION_SFS_FORMAT) {
800 struct TagItem *taglist=(struct TagItem *)globals->packet->dp_Arg1;
801 struct TagItem *tag;
802
803 while((tag=NextTagItem(&taglist))) {
804 switch(tag->ti_Tag) {
805 case ASF_NAME:
806 name=(UBYTE *)tag->ti_Data;
807 break;
808 case ASF_RECYCLEDNAME:
809 recycledname=(UBYTE *)tag->ti_Data;
810 break;
811 case ASF_CASESENSITIVE:
812 casesensitive=tag->ti_Data;
813 break;
814 case ASF_NORECYCLED:
815 norecycled=tag->ti_Data;
816 break;
817 case ASF_SHOWRECYCLED:
818 showrecycled=tag->ti_Data;
819 break;
820 }
821 }
822 }
823 else {
824 copybstrasstr((BSTR)globals->packet->dp_Arg1, globals->string, 30);
825 name=globals->string;
826 }
827
828 /* Global block numbers */
829
830 globals->block_adminspace=globals->blocks_reserved_start;
831 globals->block_root=globals->blocks_reserved_start+1;
832 globals->block_extentbnoderoot=globals->block_root+3;
833 globals->block_bitmapbase=globals->block_adminspace+globals->blocks_admin;
834 globals->block_objectnoderoot=globals->block_root+4;
835
836 /* Temporary block numbers */
837
838 block_recycled=globals->block_root+5;
839
840 cb=getcachebuffer();
841
842 if(isvalidcomponentname(name)==FALSE || isvalidcomponentname(recycledname)==FALSE) {
843 errorcode=ERROR_INVALID_COMPONENT_NAME;
844 }
845
846 if(errorcode==0) {
847 struct fsAdminSpaceContainer *ac=cb->data;
848
849 _DEBUG(("ACTION_FORMAT: Creating AdminSpace container block\n"));
850
851 /* Create AdminSpaceContainer block */
852
853 cb->blckno=globals->block_adminspace;
854 clearcachebuffer(cb);
855
856 ac->bheader.id=ADMINSPACECONTAINER_ID;
857 ac->bheader.be_ownblock=L2BE(globals->block_adminspace);
858 ac->bits=globals->blocks_admin;
859 ac->adminspace[0].be_space=L2BE(globals->block_adminspace);
860
861 if(norecycled==FALSE) {
862 /* NOT HASHED RECYCLED
863 ac->adminspace[0].be_bits=L2BE(0xFF000000); // admin + root + hashtable + restore + 2 * nodecontainers + recycled + hash
864 */
865 ac->adminspace[0].be_bits=L2BE(0xFE000000); /* admin + root + hashtable + restore + 2 * nodecontainers + recycled */
866 }
867 else {
868 ac->adminspace[0].be_bits=L2BE(0xFC000000); /* admin + root + hashtable + restore + 2 * nodecontainers */
869 }
870
871 setchecksum(cb);
872 errorcode=writecachebuffer(cb);
873 }
874
875 if(errorcode==0) {
876 struct fsObjectContainer *oc=cb->data;
877 struct fsRootInfo *ri=(struct fsRootInfo *)((UBYTE *)cb->data+globals->bytes_block-sizeof(struct fsRootInfo));
878
879 _DEBUG(("ACTION_FORMAT: Creating Root block\n"));
880
881 /* Create Root block */
882
883 cb->blckno=globals->block_root;
884 clearcachebuffer(cb);
885
886 oc->bheader.id=OBJECTCONTAINER_ID;
887 oc->bheader.be_ownblock=L2BE(globals->block_root);
888 oc->object[0].be_protection=L2BE(FIBF_READ|FIBF_WRITE|FIBF_EXECUTE|FIBF_DELETE);
889 oc->object[0].be_datemodified=L2BE(currentdate);
890 oc->object[0].bits=OTYPE_DIR;
891 oc->object[0].be_objectnode=L2BE(ROOTNODE);
892
893 oc->object[0].object.dir.be_hashtable=L2BE(globals->block_root+1);
894
895 if(norecycled==FALSE) {
896 oc->object[0].object.dir.be_firstdirblock=L2BE(block_recycled);
897 }
898
899 copystr(name, oc->object[0].name, 30);
900
901 ri->be_freeblocks=L2BE(globals->blocks_total-globals->blocks_admin-globals->blocks_reserved_start-globals->blocks_reserved_end-globals->blocks_bitmap);
902 ri->be_datecreated=oc->object[0].be_datemodified; // BE-BE copy
903
904 setchecksum(cb);
905 errorcode=writecachebuffer(cb);
906 }
907
908 if(errorcode==0) {
909 struct fsHashTable *ht=cb->data;
910
911 _DEBUG(("ACTION_FORMAT: Creating Root's HashTable block\n"));
912
913 /* Create Root's HashTable block */
914
915 cb->blckno=globals->block_root+1;
916 clearcachebuffer(cb);
917
918 ht->bheader.id=HASHTABLE_ID;
919 ht->bheader.be_ownblock=L2BE(globals->block_root+1);
920 ht->be_parent=L2BE(ROOTNODE);
921
922 if(norecycled==FALSE) {
923 ht->be_hashentry[HASHCHAIN(hash(".recycled", casesensitive))]=L2BE(RECYCLEDNODE);
924 }
925
926 setchecksum(cb);
927 errorcode=writecachebuffer(cb);
928 }
929
930 if(errorcode==0) {
931 struct fsBlockHeader *bh=cb->data;
932
933 _DEBUG(("ACTION_FORMAT: Creating Transaction block\n"));
934
935 /* Create empty block as a placeholder for the TransactionFailure block. */
936
937 cb->blckno=globals->block_root+2;
938 clearcachebuffer(cb);
939
940 bh->id=TRANSACTIONOK_ID;
941 bh->be_ownblock=L2BE(globals->block_root+2);
942
943 setchecksum(cb);
944 errorcode=writecachebuffer(cb);
945 }
946
947 if(errorcode==0) {
948 struct fsBNodeContainer *bnc=cb->data;
949 struct BTreeContainer *btc=&bnc->btc;
950
951 _DEBUG(("ACTION_FORMAT: Creating ExtentNode root block\n"));
952
953 /* Create NodeContainer block for ExtentNodes */
954
955 cb->blckno=globals->block_extentbnoderoot;
956 clearcachebuffer(cb);
957
958 bnc->bheader.id=BNODECONTAINER_ID;
959 bnc->bheader.be_ownblock=L2BE(globals->block_extentbnoderoot);
960
961 btc->isleaf=TRUE;
962 btc->be_nodecount=0;
963 btc->nodesize=sizeof(struct fsExtentBNode);
964
965 setchecksum(cb);
966 errorcode=writecachebuffer(cb);
967 }
968
969 if(errorcode==0) {
970 struct fsNodeContainer *nc=cb->data;
971 struct fsObjectNode *on;
972
973 _DEBUG(("ACTION_FORMAT: Creating ObjectNode root block\n"));
974
975 /* Create NodeContainer block for ObjectNodes */
976
977 cb->blckno=globals->block_objectnoderoot;
978 clearcachebuffer(cb);
979
980 nc->bheader.id=NODECONTAINER_ID;
981 nc->bheader.be_ownblock=L2BE(globals->block_objectnoderoot);
982
983 nc->be_nodenumber=L2BE(1); /* objectnode 0 is reserved :-) */
984 nc->be_nodes=L2BE(1);
985
986 on=(struct fsObjectNode *)nc->be_node;
987 on->node.be_data=L2BE(globals->block_root);
988
989 on++;
990 if(norecycled==FALSE) {
991 on->node.be_data=L2BE(block_recycled);
992 on->be_hash16=W2BE(hash(".recycled", casesensitive));
993 }
994 else {
995 on->node.be_data=-1; // reserved 2
996 }
997
998 on++;
999 on->node.be_data=-1; // reserved 3
1000
1001 on++;
1002 on->node.be_data=-1; // reserved 4
1003
1004 on++;
1005 on->node.be_data=-1; // reserved 5
1006
1007 on++;
1008 on->node.be_data=-1; // reserved 6
1009
1010 setchecksum(cb);
1011 errorcode=writecachebuffer(cb);
1012 }
1013
1014 if(errorcode==0 && norecycled==FALSE) {
1015 struct fsObjectContainer *oc=cb->data;
1016
1017 _DEBUG(("ACTION_FORMAT: Creating Root ObjectContainer block\n"));
1018
1019 cb->blckno=block_recycled;
1020 clearcachebuffer(cb);
1021
1022 oc->bheader.id=OBJECTCONTAINER_ID;
1023 oc->bheader.be_ownblock=L2BE(block_recycled);
1024 oc->be_parent=L2BE(ROOTNODE);
1025 oc->object[0].be_protection=L2BE(FIBF_READ|FIBF_WRITE);
1026 oc->object[0].be_datemodified=L2BE(currentdate);
1027 oc->object[0].bits=OTYPE_DIR|OTYPE_UNDELETABLE|OTYPE_QUICKDIR;
1028 if(showrecycled==FALSE) {
1029 oc->object[0].bits|=OTYPE_HIDDEN;
1030 }
1031
1032 oc->object[0].be_objectnode=L2BE(RECYCLEDNODE);
1033
1034 /* NOT HASHED RECYCLED
1035 oc->object[0].object.dir.hashtable=block_recycled+1;
1036 */
1037 oc->object[0].object.dir.be_hashtable=0;
1038
1039 copystr(".recycled",oc->object[0].name,30);
1040
1041 setchecksum(cb);
1042 errorcode=writecachebuffer(cb);
1043 }
1044
1045 /* NOT HASHED RECYCLED
1046 if(errorcode==0 && norecycled==FALSE) {
1047 struct fsHashTable *ht=cb->data;
1048
1049 _DEBUG(("ACTION_FORMAT: Creating Recycled's HashTable block\n"));
1050
1051 cb->blckno=block_recycled+1;
1052 clearcachebuffer(cb);
1053
1054 ht->bheader.id=HASHTABLE_ID;
1055 ht->bheader.ownblock=block_recycled+1;
1056 ht->parent=RECYCLEDNODE;
1057
1058 setchecksum(cb);
1059 errorcode=writecachebuffer(cb);
1060 }
1061 */
1062
1063 if(errorcode==0) {
1064 struct fsBitmap *bm;
1065 UWORD cnt,cnt2;
1066 ULONG block=globals->block_bitmapbase;
1067 LONG startfree=globals->blocks_admin+globals->blocks_bitmap+globals->blocks_reserved_start;
1068 LONG sizefree;
1069
1070 _DEBUG(("ACTION_FORMAT: Creating the Bitmap blocks\n"));
1071
1072 /* Create Bitmap blocks */
1073
1074 sizefree=globals->blocks_total-startfree-globals->blocks_reserved_end;
1075
1076 cnt=globals->blocks_bitmap;
1077 while(cnt-->0 && errorcode==0) {
1078 clearcachebuffer(cb);
1079
1080 bm=cb->data;
1081 bm->bheader.id=BITMAP_ID;
1082 bm->bheader.be_ownblock=L2BE(block);
1083
1084 for(cnt2=0; cnt2<(globals->blocks_inbitmap>>5); cnt2++) {
1085 if(startfree>0) {
1086 startfree-=32;
1087 if(startfree<0) {
1088 bm->bitmap[cnt2]=AROS_LONG2BE((1<<(-startfree))-1);
1089 sizefree+=startfree;
1090 }
1091 }
1092 else if(sizefree>0) {
1093 sizefree-=32;
1094 if(sizefree<0) {
1095 bm->bitmap[cnt2]=AROS_LONG2BE(~((1<<(-sizefree))-1));
1096 }
1097 else {
1098 bm->bitmap[cnt2]=BITMAPFILL;
1099 }
1100 }
1101 else {
1102 break;
1103 }
1104 }
1105
1106 cb->blckno=block++;
1107
1108 setchecksum(cb);
1109 errorcode=writecachebuffer(cb);
1110 }
1111 }
1112
1113 if(errorcode==0) {
1114 struct fsRootBlock *rb;
1115
1116 _DEBUG(("ACTION_FORMAT: Creating the Root blocks\n"));
1117
1118 /* Create Root blocks */
1119
1120 cb->blckno=0;
1121 clearcachebuffer(cb);
1122
1123 rb=cb->data;
1124 rb->bheader.id=L2BE(DOSTYPE_ID);
1125 rb->bheader.be_ownblock=0;
1126
1127 rb->be_version=W2BE(STRUCTURE_VERSION);
1128 rb->be_sequencenumber=0;
1129
1130 rb->be_datecreated=L2BE(currentdate);
1131
1132 rb->be_firstbyteh = L2BE(globals->byte_low >> 32);
1133 rb->be_firstbyte = L2BE(globals->byte_low);
1134 rb->be_lastbyteh = L2BE(globals->byte_high >> 32);
1135 rb->be_lastbyte = L2BE(globals->byte_high);
1136
1137 rb->be_totalblocks=L2BE(globals->blocks_total);
1138 rb->be_blocksize=L2BE(globals->bytes_block);
1139
1140 rb->be_bitmapbase=L2BE(globals->block_bitmapbase);
1141 rb->be_adminspacecontainer=L2BE(globals->block_adminspace);
1142 rb->be_rootobjectcontainer=L2BE(globals->block_root);
1143 rb->be_extentbnoderoot=L2BE(globals->block_extentbnoderoot);
1144 rb->be_objectnoderoot=L2BE(globals->block_objectnoderoot);
1145
1146 if(casesensitive!=FALSE) {
1147 rb->bits|=ROOTBITS_CASESENSITIVE;
1148 }
1149 if(norecycled==FALSE) {
1150 rb->bits|=ROOTBITS_RECYCLED;
1151 }
1152
1153 setchecksum(cb);
1154 if((errorcode=writecachebuffer(cb))==0) {
1155 cb->blckno=globals->blocks_total-1;
1156
1157 _DEBUG(("ACTION_FORMAT: Creating the 2nd Root block\n"));
1158
1159 rb->bheader.be_ownblock=L2BE(globals->blocks_total-1);
1160
1161 setchecksum(cb);
1162 errorcode=writecachebuffer(cb);
1163 }
1164 }
1165
1166 flushiocache();
1167 update();
1168 motoroff();
1169
1170 if(errorcode!=0) {
1171 _DEBUG(("ACTION_FORMAT: Exiting with errorcode %ld\n",errorcode));
1172
1173 returnpacket(DOSFALSE, errorcode);
1174 }
1175 else {
1176 returnpacket(DOSTRUE, 0);
1177 }
1178 }
1179
1180 break;
1181 case ACTION_INHIBIT:
1182 _DEBUG(("ACTION_INHIBIT(%ld)\n",globals->packet->dp_Arg1));
1183
1184 /* This function nests. Each call to inhibit the disk should be matched
1185 with one to uninhibit the disk. */
1186
1187 if(globals->packet->dp_Arg1!=DOSFALSE) {
1188 #ifdef STARTDEBUG
1189 dreq("Disk inhibited (nesting = %ld).", globals->inhibitnestcounter);
1190 #endif
1191
1192 if(globals->inhibitnestcounter++==0) { // Inhibited for the first time?
1193 globals->disktype=ID_BUSY; /* Must be put before deinitdisk() Feb 27 1999: Maybe not needed anymore */
1194 deinitdisk();
1195 }
1196
1197 returnpacket(DOSTRUE,0);
1198 }
1199 else if(globals->inhibitnestcounter>0 && --globals->inhibitnestcounter==0) {
1200
1201 returnpacket(DOSTRUE, 0); /* Workbench keeps doslist locked, and doesn't send any packets
1202 during that time to this handler. As initdisk() needs to lock
1203 the doslist we MUST return the packet before calling initdisk() */
1204 initdisk();
1205 }
1206 else {
1207 /* Workbench revokes ACTION_INHIBIT without ever actually having
1208 inhibited the volume. We'll just return the packet and ignore
1209 such requests. */
1210
1211 returnpacket(DOSTRUE,0);
1212 }
1213 break;
1214 case ACTION_SERIALIZE_DISK:
1215 _DEBUG(("ACTION_SERIALIZE_DISK\n"));
1216
1217 {
1218 struct CacheBuffer *cb;
1219 LONG errorcode;
1220
1221 if((errorcode=readcachebuffercheck(&cb,globals->block_root,OBJECTCONTAINER_ID))==0) {
1222 struct fsObjectContainer *oc=cb->data;
1223 struct fsRootInfo *ri=(struct fsRootInfo *)((UBYTE *)cb->data+globals->bytes_block-sizeof(struct fsRootInfo));
1224
1225 oc->object[0].be_datemodified=L2BE(getdate());
1226 ri->be_datecreated=oc->object[0].be_datemodified; // BE-BE copy
1227
1228 setchecksum(cb);
1229 errorcode=writecachebuffer(cb);
1230 }
1231
1232 if(errorcode!=0) {
1233 returnpacket(DOSFALSE,errorcode);
1234 }
1235 else {
1236 returnpacket(DOSTRUE,0);
1237 }
1238 }
1239
1240 break;
1241 default:
1242 if(handlesimplepackets(globals->packet)==0) {
1243
1244 if(globals->disktype == DOSTYPE_ID) {
1245 switch(globals->packet->dp_Type) {
1246 case ACTION_MAKE_LINK:
1247 _DEBUG(("ACTION_MAKE_LINK\n"));
1248
1249 {
1250 if(globals->packet->dp_Arg4==LINK_HARD) {
1251 returnpacket(DOSFALSE,ERROR_ACTION_NOT_KNOWN);
1252 }
1253 /* else if(packet->dp_Arg4!=LINK_SOFT) {
1254 returnpacket(DOSFALSE,ERROR_BAD_NUMBER);
1255 } */ /* Check removed because DOS apparantely defines non-zero as being a Soft link! */
1256 else {
1257 struct ExtFileLock *lock;
1258 LONG errorcode;
1259
1260 lock=(struct ExtFileLock *)BADDR(globals->packet->dp_Arg1);
1261 copybstrasstr((BSTR)globals->packet->dp_Arg2,globals->string,258);
1262
1263 _DEBUG(("ACTION_MAKE_LINK: Name = '%s', LinkPath = '%s'\n",globals->string,(UBYTE *)globals->packet->dp_Arg3));
1264
1265 if((errorcode=findcreate(&lock,globals->string,globals->packet->dp_Type,(UBYTE *)globals->packet->dp_Arg3))!=0) {
1266 returnpacket(DOSFALSE,errorcode);
1267 }
1268 else {
1269 // freelock(lock);
1270 returnpacket(DOSTRUE,0);
1271 }
1272 }
1273 }
1274
1275 break;
1276 case ACTION_READ_LINK:
1277 _DEBUG(("ACTION_READ_LINK\n"));
1278
1279 {
1280 struct CacheBuffer *cb;
1281 struct fsObject *o;
1282 struct ExtFileLock *lock;
1283 UBYTE *dest=(UBYTE *)globals->packet->dp_Arg3;
1284 LONG errorcode;
1285 NODE objectnode;
1286
1287 lock=(struct ExtFileLock *)BADDR(globals->packet->dp_Arg1);
1288
1289 if(lock==0) {
1290 objectnode=ROOTNODE;
1291 }
1292 else {
1293 objectnode=lock->objectnode;
1294 }
1295
1296 if((errorcode=readobject(objectnode, &cb, &o))==0) {
1297 UBYTE *path=(UBYTE *)globals->packet->dp_Arg2, *prefix=path;
1298
1299 _DEBUG(("ACTION_READ_LINK: path = '%s', errorcode = %ld\n",path,errorcode));
1300
1301 errorcode=locateobject2(&path, &cb, &o);
1302
1303 if(errorcode!=ERROR_IS_SOFT_LINK) {
1304 errorcode=ERROR_OBJECT_NOT_FOUND;
1305 }
1306 else {
1307 struct CacheBuffer *cb2;
1308 UBYTE *p=path;
1309
1310 /* Move on to remainder of path after the link */
1311
1312 while(*path!=0) {
1313 if(*path=='/') {
1314 break;
1315 }
1316 path++;
1317 }
1318
1319 _DEBUG(("ACTION_READ_LINK: path = '%s'\n",path));
1320
1321 if((errorcode=readcachebuffercheck(&cb2, BE2L(o->object.file.be_data), SOFTLINK_ID))==0) {
1322 struct fsSoftLink *sl=cb2->data;
1323 LONG length=globals->packet->dp_Arg4;
1324 UBYTE *src=sl->string, ch;
1325 UBYTE *s=globals->string;
1326
1327 while((*s++=*path++)!=0) { // Work-around for bug in ixemul, which sometimes provides the same pointer for dp_Arg2 (path) and dp_Arg3 (soft-link buffer)
1328 }
1329
1330 s=globals->string;
1331
1332 _DEBUG(("ACTION_READ_LINK: length = %ld, sl->string = '%s', path = '%s'\n", length, sl->string, s));
1333
1334 /* cb is no longer valid at this point. */
1335
1336 /* Check if link target is an absolute path */
1337
1338 while((ch=*src++)!='\0') {
1339 if(ch==':')
1340 break;
1341 }
1342 src=sl->string;
1343
1344 /* If target is a relative path, put path preceding
1345 link into buffer so that result is relative to
1346 lock passed in */
1347
1348 if(ch!=':') {
1349 while(prefix!=p && length-->0) {
1350 *dest++=*prefix++;
1351 }
1352 }
1353
1354 /* Copy link target to buffer */
1355
1356 while(length-->0 && (*dest++=*src++)!=0) {
1357 }
1358 dest--;
1359 length++;
1360
1361 /* Ensure we don't insert an extraneous slash */
1362
1363 if(length!=globals->packet->dp_Arg4 && *(dest-1)=='/') {
1364 *--dest='\0';
1365 length++;
1366 }
1367 if(*(dest-1)==':' && *s=='/') {
1368 s++;
1369 }
1370
1371 /* Append remainder of original path */
1372
1373 while(length-->0 && (*dest++=*s++)!=0) {
1374 }
1375
1376 if(length<0) {
1377 errorcode=ERROR_LINE_TOO_LONG;
1378 }
1379 }
1380 }
1381 }
1382
1383 if(errorcode!=0) {
1384 if(errorcode==ERROR_LINE_TOO_LONG) {
1385 returnpacket(-2, errorcode);
1386 }
1387 else {
1388 returnpacket(-1, errorcode);
1389 }
1390 }
1391 else {
1392 returnpacket((LONG)((SIPTR)dest - globals->packet->dp_Arg3 - 1),
1393 0);
1394 }
1395 }
1396 break;
1397 case ACTION_CREATE_DIR:
1398 _DEBUG(("ACTION_CREATE_DIR\n"));
1399
1400 {
1401 struct ExtFileLock *lock;
1402 LONG errorcode;
1403
1404 lock=(struct ExtFileLock *)BADDR(globals->packet->dp_Arg1);
1405 copybstrasstr((BSTR)globals->packet->dp_Arg2,globals->string,258);
1406
1407 if((errorcode=findcreate(&lock,globals->string,globals->packet->dp_Type,0))!=0) {
1408 returnpacket(0,errorcode);
1409 }
1410 else {
1411 returnpacket((SIPTR)TOBADDR(lock),0);
1412 }
1413 }
1414
1415 break;
1416 case ACTION_FINDUPDATE:
1417 case ACTION_FINDINPUT:
1418 case ACTION_FINDOUTPUT:
1419 case ACTION_FH_FROM_LOCK:
1420 _XDEBUG((DEBUG_OBJECTS, "ACTION_FIND#? or ACTION_FH_FROM_LOCK\n"));
1421
1422 {
1423 struct ExtFileLock *lock;
1424 struct FileHandle *fh;
1425 LONG errorcode=0;
1426
1427 fh=(struct FileHandle *)BADDR(globals->packet->dp_Arg1);
1428 lock=(struct ExtFileLock *)BADDR(globals->packet->dp_Arg2);
1429
1430 if(globals->packet->dp_Type!=ACTION_FH_FROM_LOCK) {
1431 copybstrasstr((BSTR)globals->packet->dp_Arg3,globals->string,258);
1432 _DEBUG(("OPEN FILE: %s (mode = %ld)\n", globals->string, globals->packet->dp_Type));
1433 errorcode=findcreate(&lock,globals->string,globals->packet->dp_Type,0);
1434 }
1435
1436 if(errorcode==0) {
1437 if((errorcode=createglobalhandle(lock))==0) {
1438 fh->fh_Arg1=(IPTR)lock;
1439 }
1440 else if(globals->packet->dp_Type!=ACTION_FH_FROM_LOCK) {
1441 freelock(lock);
1442 }
1443 }
1444
1445 if(errorcode!=0) {
1446 returnpacket(DOSFALSE,errorcode);
1447 }
1448 else {
1449 if(globals->packet->dp_Type==ACTION_FINDOUTPUT && globals->has_recycled!=FALSE) {
1450 ULONG files,blocks;
1451
1452 if((errorcode=getrecycledinfo(&files, &blocks))==0) {
1453 if(files>35) {
1454 cleanupdeletedfiles();
1455 }
1456 }
1457 }
1458
1459 returnpacket(DOSTRUE,0);
1460 }
1461 }
1462
1463 break;
1464 case ACTION_END:
1465 _XDEBUG((DEBUG_OBJECTS, "ACTION_END\n"));
1466
1467 /* ACTION_FREE_LOCK's code is similair */
1468
1469 {
1470 struct ExtFileLock *lock=(struct ExtFileLock *)globals->packet->dp_Arg1;
1471 LONG errorcode;
1472
1473 /* If a file has been modified by the use of ACTION_SET_FILE_SIZE or
1474 ACTION_WRITE, or ACTION_FINDOUTPUT or ACTION_FINDUPDATE (only when
1475 creating a new file) were used to create the file then we must
1476 also update the datestamp of the file. We also must send out a
1477 notification. Finally we also need to clear the A bit.
1478
1479 For this purpose a special flag in the lock tells us
1480 whether or not any of the above actions has occured. */
1481
1482 if((lock->bits & EFL_MODIFIED) != 0) {
1483 struct CacheBuffer *cb;
1484 struct fsObject *o;
1485
1486 /* Aha! */
1487
1488 if(lock->lastextendedblock!=0) {
1489 globals->block_rovingblockptr=lock->lastextendedblock;
1490 if(globals->block_rovingblockptr>=globals->blocks_total) {
1491 globals->block_rovingblockptr=0;
1492 }
1493 }
1494
1495 if((errorcode=readobject(lock->objectnode, &cb, &o))==0) {
1496 newtransaction();
1497
1498 errorcode=bumpobject(cb, o);
1499 checknotifyforobject(cb, o, TRUE);
1500
1501 if(errorcode==0) {
1502 endtransaction();
1503 }
1504 else {
1505 deletetransaction();
1506 }
1507 }
1508
1509 /* Ignore any errorcodes -- not really interesting when closing a file... */
1510 }
1511
1512 if((errorcode=freelock(lock))!=0) {
1513 returnpacket(DOSFALSE,errorcode);
1514 }
1515 else {
1516 returnpacket(DOSTRUE,0);
1517 }
1518 }
1519 break;
1520 case ACTION_DELETE_OBJECT:
1521 {
1522 LONG errorcode;
1523
1524 copybstrasstr((BSTR)globals->packet->dp_Arg2,globals->string,258);
1525
1526 _DEBUG(("ACTION_DELETE_OBJECT(0x%08lx,'%s')\n",BADDR(globals->packet->dp_Arg1),globals->string));
1527
1528 do {
1529 newtransaction();
1530
1531 if((errorcode=deleteobject(BADDR(globals->packet->dp_Arg1), validatepath(globals->string), TRUE))==0) {
1532 endtransaction();
1533 }
1534 else {
1535 deletetransaction();
1536 }
1537 } while(errorcode==ERROR_DISK_FULL && freeupspace()!=FALSE);
1538
1539 if(errorcode!=0) {
1540 returnpacket(DOSFALSE,errorcode);
1541 }
1542 else {
1543 ULONG files,blocks;
1544
1545 if((errorcode=getrecycledinfo(&files, &blocks))==0) {
1546 if(files>35) {
1547 cleanupdeletedfiles();
1548 }
1549 }
1550
1551 returnpacket(DOSTRUE,0);
1552 }
1553 }
1554 break;
1555 case ACTION_RENAME_DISK:
1556 _DEBUG(("ACTION_RENAME_DISK\n"));
1557
1558 {
1559 struct CacheBuffer *cb;
1560 LONG errorcode;
1561
1562 if((errorcode=readcachebuffercheck(&cb,globals->block_root,OBJECTCONTAINER_ID))==0) {
1563 if(AttemptLockDosList(LDF_WRITE|LDF_VOLUMES)!=0) {
1564 struct fsObjectContainer *oc=cb->data;
1565 UBYTE *s;
1566 UBYTE *d;
1567 #ifndef USE_FAST_BSTR
1568 UBYTE len;
1569 #endif
1570
1571 /* Succesfully locked the doslist */
1572
1573 newtransaction();
1574
1575 preparecachebuffer(cb);
1576
1577
1578 s=BADDR(globals->packet->dp_Arg1);
1579 d=oc->object[0].name;
1580 d[copybstrasstr((BSTR)globals->packet->dp_Arg1, d, 30)+1] = 0;
1581 #if 0
1582 len=*s++;
1583
1584 if(len>30) {
1585 len=30;
1586 }
1587
1588 while(len-->0) {
1589 *d++=*s++;
1590 }
1591 *d++=0;
1592 *d=0; /* Zero for comment */
1593 #endif
1594 if((errorcode=storecachebuffer(cb))==0 && globals->volumenode!=0) {
1595 s=BADDR(globals->packet->dp_Arg1);
1596 d=BADDR(globals->volumenode->dl_Name);
1597 #ifdef USE_FAST_BSTR
1598 copystr(s, d, 30);
1599 #else
1600 len=*s++;
1601
1602 if(len>30) {
1603 len=30;
1604 }
1605
1606 *d++=len;
1607 while(len-->0) {
1608 *d++=*s++;
1609 }
1610 *d=0;
1611 #endif
1612 }
1613
1614 UnLockDosList(LDF_WRITE|LDF_VOLUMES);
1615
1616 if(errorcode==0) {
1617 endtransaction();
1618 }
1619 else {
1620 deletetransaction();
1621 }
1622 }
1623 else {
1624 /* Doslist locking attempt was unsuccesful. Send this message back to our
1625 port to try it again later. */
1626
1627 PutMsg(msgportpackets,msg);
1628 break;
1629 }
1630 }
1631
1632 if(errorcode==0) {
1633 returnpacket(DOSTRUE,0);
1634 }
1635 else {
1636 returnpacket(DOSFALSE,errorcode);
1637 }
1638 }
1639 break;
1640 case ACTION_RENAME_OBJECT:
1641 _DEBUG(("ACTION_RENAME_OBJECT\n"));
1642
1643 {
1644 LONG errorcode;
1645
1646 do {
1647 struct CacheBuffer *cb;
1648 struct fsObject *o;
1649 struct ExtFileLock *lock;
1650 UBYTE *newname;
1651 UBYTE *s;
1652
1653 lock=BADDR(globals->packet->dp_Arg1);
1654 copybstrasstr((BSTR)globals->packet->dp_Arg2,globals->string,258);
1655
1656 if((errorcode=locateobjectfromlock(lock,validatepath(globals->string),&cb,&o))==0) {
1657 copybstrasstr((BSTR)globals->packet->dp_Arg4,globals->string,258);
1658
1659 settemporarylock(BE2L(o->be_objectnode));
1660
1661 newname=validatepath(globals->string);
1662 s=FilePart(newname);
1663
1664 if(*s!=0) {
1665 newtransaction();
1666 if((errorcode=renameobject(cb,o,BADDR(globals->packet->dp_Arg3),newname))==0) {
1667 endtransaction();
1668 }
1669 else {
1670 deletetransaction();
1671 }
1672 }
1673 else {
1674 errorcode=ERROR_INVALID_COMPONENT_NAME;
1675 }
1676 }
1677 } while(errorcode==ERROR_DISK_FULL && freeupspace()!=FALSE);
1678
1679 cleartemporarylock();
1680
1681 if(errorcode!=0) {
1682 returnpacket(DOSFALSE,errorcode);
1683 }
1684 else {
1685 returnpacket(DOSTRUE,0);
1686 }
1687 }
1688 break;
1689 case ACTION_SET_COMMENT:
1690 _DEBUG(("ACTION_SET_COMMENT\n"));
1691 {
1692 LONG errorcode;
1693
1694 do {
1695 copybstrasstr((BSTR)globals->packet->dp_Arg3,globals->string,258);
1696 copybstrasstr((BSTR)globals->packet->dp_Arg4,globals->string2,258);
1697
1698 newtransaction();
1699 if((errorcode=setcomment(BADDR(globals->packet->dp_Arg2),validatepath(globals->string),globals->string2))!=0) {
1700 deletetransaction();
1701 }
1702 else {
1703 endtransaction();
1704 }
1705 } while(errorcode==ERROR_DISK_FULL && freeupspace()!=FALSE);
1706
1707 if(errorcode!=0) {
1708 returnpacket(DOSFALSE,errorcode);
1709 }
1710 else {
1711 returnpacket(DOSTRUE,0);
1712 }
1713 }
1714 break;
1715 case ACTION_SET_DATE:
1716 case ACTION_SET_PROTECT:
1717 case ACTION_SET_OWNER:
1718 case ACTION_SFS_SET_OBJECTBITS:
1719 _XDEBUG((DEBUG_OBJECTS, "ACTION_SET_DATE or ACTION_SET_PROTECT or ACTION_SET_OWNER\n"));
1720
1721 {
1722 LONG errorcode;
1723
1724 do {
1725 struct CacheBuffer *cb;
1726 struct fsObject *o;
1727 struct ExtFileLock *lock;
1728
1729 lock=BADDR(globals->packet->dp_Arg2);
1730 copybstrasstr((BSTR)globals->packet->dp_Arg3,globals->string,258);
1731
1732 if((errorcode=locatelockableobject(lock,validatepath(globals->string),&cb,&o))==0) {
1733 NODE objectnode=BE2L(o->be_objectnode);
1734
1735 if(objectnode!=ROOTNODE) {
1736
1737 settemporarylock(objectnode);
1738
1739 newtransaction();
1740 preparecachebuffer(cb);
1741
1742 if(globals->packet->dp_Type==ACTION_SET_DATE) {
1743 checksum_writelong_be(cb->data, &o->be_datemodified, datestamptodate((struct DateStamp *)globals->packet->dp_Arg4));
1744
1745 // o->datemodified=datestamptodate((struct DateStamp *)packet->dp_Arg4);
1746 }
1747 else if(globals->packet->dp_Type==ACTION_SET_PROTECT) {
1748 checksum_writelong_be(cb->data, &o->be_protection, globals->packet->dp_Arg4^(FIBF_READ|FIBF_WRITE|FIBF_EXECUTE|FIBF_DELETE));
1749
1750 // o->protection=packet->dp_Arg4^(FIBF_READ|FIBF_WRITE|FIBF_EXECUTE|FIBF_DELETE);
1751 }
1752 else if(globals->packet->dp_Type==ACTION_SET_OWNER) {
1753 // ULONG *owner=(ULONG *)&o->owneruid;
1754
1755 checksum_writelong_be(cb->data, (ULONG *)&o->be_owneruid, globals->packet->dp_Arg4);
1756
1757 // *owner=packet->dp_Arg4;
1758 }
1759 else {
1760 o->bits=(globals->packet->dp_Arg4 & (OTYPE_HIDDEN|OTYPE_UNDELETABLE)) | (o->bits & ~(OTYPE_HIDDEN|OTYPE_UNDELETABLE));
1761 setchecksum(cb); // new
1762 }
1763
1764 if((errorcode=storecachebuffer_nochecksum(cb))==0) {
1765 struct GlobalHandle *gh;
1766
1767 checknotifyforobject(cb,o,TRUE);
1768 endtransaction();
1769
1770 if(globals->packet->dp_Type==ACTION_SET_PROTECT && (gh=findglobalhandle(objectnode))!=0) {
1771 gh->protection=globals->packet->dp_Arg4^(FIBF_READ|FIBF_WRITE|FIBF_EXECUTE|FIBF_DELETE);
1772 }
1773 }
1774 else {
1775 deletetransaction();
1776 }
1777 }
1778 else {
1779 errorcode=ERROR_OBJECT_WRONG_TYPE;
1780 }
1781 }
1782
1783 /* this 'loop' will only be left if the disk wasn't full, or
1784 cleanupdeletedfiles() couldn't free up any more space. */
1785
1786 } while(errorcode==ERROR_DISK_FULL && freeupspace()!=FALSE);
1787
1788 cleartemporarylock();
1789
1790 if(errorcode!=0) {
1791 returnpacket(DOSFALSE,errorcode);
1792 }
1793 else {
1794 returnpacket(DOSTRUE,0);
1795 }
1796 }
1797 break;
1798 case ACTION_SET_FILE_SIZE:
1799 _DEBUG(("ACTION_SET_FILE_SIZE(0x%08lx,0x%08lx,0x%08lx)\n",globals->packet->dp_Arg1,globals->packet->dp_Arg2,globals->packet->dp_Arg3));
1800
1801 {
1802 struct ExtFileLock *lock=(struct ExtFileLock *)globals->packet->dp_Arg1;
1803 LONG newfilesize;
1804 LONG errorcode;
1805
1806 if(globals->packet->dp_Arg3==OFFSET_BEGINNING) {
1807 newfilesize=globals->packet->dp_Arg2;
1808 }
1809 else if(globals->packet->dp_Arg3==OFFSET_END) {
1810 newfilesize=lock->gh->size+globals->packet->dp_Arg2;
1811 }
1812 else if(globals->packet->dp_Arg3==OFFSET_CURRENT) {
1813 newfilesize=lock->offset+globals->packet->dp_Arg2;
1814 }
1815 else {
1816 returnpacket(-1,ERROR_BAD_NUMBER);
1817 break;
1818 }
1819
1820 if(newfilesize>=0) {
1821 ULONG data=lock->gh->data;
1822
1823 do {
1824 errorcode=setfilesize(lock,newfilesize);
1825 } while(errorcode==ERROR_DISK_FULL && freeupspace()!=FALSE);
1826
1827 if(errorcode!=0) {
1828 lock->gh->data=data;
1829 }
1830 }
1831 else {
1832 errorcode=ERROR_SEEK_ERROR;
1833 }
1834
1835 if(errorcode==0) {
1836 returnpacket(lock->gh->size,0);
1837 }
1838 else {
1839 returnpacket(-1,errorcode);
1840 }
1841 }
1842 break;
1843 case ACTION_SEEK:
1844 _XDEBUG((DEBUG_SEEK,"ACTION_SEEK(0x%08lx,0x%08lx,0x%08lx)\n",globals->packet->dp_Arg1,globals->packet->dp_Arg2,globals->packet->dp_Arg3));
1845
1846 {
1847 struct ExtFileLock *lock=(struct ExtFileLock *)globals->packet->dp_Arg1;
1848 struct GlobalHandle *gh=lock->gh;
1849 ULONG oldpos=lock->offset;
1850 LONG newpos;
1851 LONG errorcode;
1852
1853 if(globals->packet->dp_Arg3==OFFSET_BEGINNING) {
1854 newpos=globals->packet->dp_Arg2;
1855 }
1856 else if(globals->packet->dp_Arg3==OFFSET_END) {
1857 newpos=gh->size+globals->packet->dp_Arg2;
1858 }
1859 else if(globals->packet->dp_Arg3==OFFSET_CURRENT) {
1860 newpos=lock->offset+globals->packet->dp_Arg2;
1861 }
1862 else {
1863 returnpacket(-1,ERROR_BAD_NUMBER);
1864 break;
1865 }
1866
1867 if(newpos>=0 && newpos<=gh->size) {
1868 if(newpos!=oldpos) {
1869 errorcode=seek(lock,newpos);
1870 }
1871 else {
1872 errorcode=0;
1873 }
1874 }
1875 else {
1876 errorcode=ERROR_SEEK_ERROR;
1877 }
1878
1879 if(errorcode==0) {
1880 returnpacket(oldpos,0);
1881 }
1882 else {
1883 returnpacket(-1,errorcode);
1884 }
1885 }
1886 break;
1887 case ACTION_READ:
1888 _XDEBUG((DEBUG_IO,"ACTION_READ(0x%08lx,0x%08lx,%ld)\n",globals->packet->dp_Arg1,globals->packet->dp_Arg2,globals->packet->dp_Arg3));
1889
1890 {
1891 struct ExtFileLock *lock=(struct ExtFileLock *)globals->packet->dp_Arg1;
1892 struct GlobalHandle *gh=lock->gh;
1893 UBYTE *buffer=(UBYTE *)globals->packet->dp_Arg2;
1894 ULONG bytesleft;
1895 UBYTE *startofbuf=buffer;
1896 LONG errorcode;
1897
1898 bytesleft=globals->packet->dp_Arg3;
1899 if(lock->offset+bytesleft > gh->size) {
1900 bytesleft=gh->size-lock->offset;
1901 }
1902
1903 if((errorcode=seektocurrent(lock))==0) {
1904 if((gh->protection & FIBF_READ)!=0) {
1905 struct CacheBuffer *extent_cb;
1906 struct fsExtentBNode *ebn;
1907
1908 while(bytesleft>0 && (errorcode=findextentbnode(lock->curextent, &extent_cb, &ebn))==0) {
1909 ULONG bytestoread;
1910 ULONG offsetinblock=lock->extentoffset & globals->mask_block;
1911 BLCK ebn_next=BE2L(ebn->be_next);
1912 UWORD ebn_blocks=BE2W(ebn->be_blocks);
1913
1914 _XDEBUG((DEBUG_IO,"ACTION_READ: buffer = 0x%p bytesleft = %ld, offsetinblock = %ld, ExtentBNode = %ld, ebn->data = %ld, ebn->blocks = %ld\n",
1915 buffer, bytesleft, offsetinblock, lock->curextent, BE2L(ebn->be_key), BE2W(ebn->be_blocks)));
1916
1917 if(offsetinblock!=0 || bytesleft<globals->bytes_block) {
1918
1919 // _XDEBUG((DEBUG_IO,"ACTION_READ: nextextentbnode = %ld, extentnodesize = %ld, en->blocks = %ld\n",nextextentbnode,extentnodesize,(ULONG)ebn->blocks));
1920
1921 bytestoread=globals->bytes_block-offsetinblock;
1922
1923 /* Check if there are more bytes left in the block then we want to read */
1924 if(bytestoread > bytesleft) {
1925 bytestoread=bytesleft;
1926 }
1927
1928 if((errorcode=readbytes(BE2L(ebn->be_key)+(lock->extentoffset>>globals->shifts_block), buffer, offsetinblock, bytestoread))!=0) {
1929 break;
1930 }
1931 }
1932 else {
1933
1934 bytestoread=(((ULONG)ebn_blocks)<<globals->shifts_block) - lock->extentoffset;
1935
1936 /* Check if there are more bytes left in the Extent then we want to read */
1937 if(bytestoread > bytesleft) {
1938 bytestoread=bytesleft & ~globals->mask_block;
1939 }
1940
1941 if((errorcode=read(BE2L(ebn->be_key)+(lock->extentoffset>>globals->shifts_block), buffer, bytestoread>>globals->shifts_block))!=0) {
1942 break;
1943 }
1944 }
1945
1946 seekforward(lock, ebn_blocks, ebn_next, bytestoread);
1947
1948 bytesleft-=bytestoread;
1949 buffer+=bytestoread;
1950
1951 _XDEBUG((DEBUG_IO,"ACTION_READ: bytesleft = %ld, errorcode = %ld\n",bytesleft,errorcode));
1952 }
1953 }
1954 else {
1955 errorcode=ERROR_READ_PROTECTED;
1956 }
1957 }
1958
1959 _XDEBUG((DEBUG_IO,"ACTION_READ: errorcode = %ld, buffer = %ld, startofbuf = %ld\n",errorcode,buffer,startofbuf));
1960
1961 if(errorcode!=0) {
1962 returnpacket(-1,errorcode);
1963 }
1964 else {
1965 returnpacket(buffer-startofbuf,0);
1966 }
1967 }
1968 break;
1969 case ACTION_WRITE:
1970 _XDEBUG((DEBUG_IO,"ACTION_WRITE(0x%08lx,0x%08lx,%ld)\n",globals->packet->dp_Arg1,globals->packet->dp_Arg2,globals->packet->dp_Arg3));
1971
1972 {
1973 struct ExtFileLock *lock=(struct ExtFileLock *)globals->packet->dp_Arg1;
1974 ULONG bytestowrite=globals->packet->dp_Arg3;
1975 LONG errorcode=0;
1976
1977 do {
1978 struct GlobalHandle *gh=lock->gh;
1979
1980 /* Save some values in case of an error: */
1981
1982 BLCK curextent=lock->curextent;
1983 ULONG extentoffset=lock->extentoffset;
1984 ULONG offset=lock->offset;
1985 ULONG size=gh->size;
1986 ULONG data=gh->data;
1987
1988 if(bytestowrite!=0) {
1989 newtransaction();
1990
1991 if((errorcode=writetofile(lock, (UBYTE *)globals->packet->dp_Arg2, bytestowrite))==0) {
1992 endtransaction();
1993 }
1994 else {
1995 lock->curextent=curextent;
1996 lock->extentoffset=extentoffset;
1997 lock->offset=offset;
1998 gh->size=size;
1999 gh->data=data;
2000
2001 deletetransaction();
2002 }
2003 }
2004 } while(errorcode==ERROR_DISK_FULL && freeupspace()!=FALSE);
2005
2006 if(errorcode!=0) {
2007 _XDEBUG((DEBUG_IO,"ACTION_WRITE returns (-1, %ld)\n",errorcode));
2008
2009 returnpacket(-1,errorcode);
2010 }
2011 else {
2012 _XDEBUG((DEBUG_IO,"ACTION_WRITE returns (%ld, 0)\n",bytestowrite));
2013
2014 lock->bits|=EFL_MODIFIED;
2015 returnpacket(bytestowrite,0);
2016 }
2017 }
2018 break;
2019 case ACTION_FREE_LOCK:
2020 _XDEBUG((DEBUG_LOCK,"ACTION_FREE_LOCK\n"));
2021
2022 {
2023 LONG errorcode;
2024
2025 if((errorcode=freelock((struct ExtFileLock *)BADDR(globals->packet->dp_Arg1)))!=0) {
2026 returnpacket(DOSFALSE,errorcode);
2027 break;
2028 }
2029 returnpacket(DOSTRUE,0);
2030 }
2031 break;
2032 case ACTION_EXAMINE_ALL:
2033 _DEBUG(("ACTION_EXAMINE_ALL\n"));
2034
2035 {
2036 struct ExtFileLock *lock;
2037 struct ExAllData *ead;
2038 struct ExAllData *prevead=0;
2039 struct ExAllControl *eac;
2040 struct CacheBuffer *cb;
2041 struct fsObject *o;
2042 ULONG eadsize;
2043 ULONG stringsize;
2044 LONG spaceleft;
2045 LONG errorcode;
2046
2047 lock=(struct ExtFileLock *)BADDR(globals->packet->dp_Arg1);
2048 ead=(struct ExAllData *)globals->packet->dp_Arg2;
2049 eac=(struct ExAllControl *)globals->packet->dp_Arg5;
2050 spaceleft=globals->packet->dp_Arg3;
2051
2052 eac->eac_Entries=0;
2053
2054 if(lock==0) {
2055 _DEBUG(("ACTION_EXAMINE_ALL: Zero lock was passed in...\n"));
2056
2057 returnpacket(DOSFALSE,ERROR_OBJECT_WRONG_TYPE);
2058 break;
2059 }
2060
2061 if(globals->packet->dp_Arg4>ED_OWNER) {
2062 returnpacket(DOSFALSE,ERROR_BAD_NUMBER);
2063 break;
2064 }
2065
2066 if(eac->eac_LastKey==0) {
2067 if((errorcode=readobject(lock->objectnode,&cb,&o))==0) {
2068 if((o->bits & OTYPE_DIR)!=0) {
2069 if(o->object.dir.be_firstdirblock!=0) {
2070 if((errorcode=readcachebuffercheck(&cb,BE2L(o->object.dir.be_firstdirblock),OBJECTCONTAINER_ID))==0) {
2071 struct fsObjectContainer *oc=cb->data;
2072
2073 o=oc->object;
2074 eac->eac_LastKey=BE2L(o->be_objectnode);
2075 }
2076 }
2077 else {
2078 errorcode=ERROR_NO_MORE_ENTRIES;
2079 }
2080 }
2081 else {
2082 errorcode=ERROR_OBJECT_WRONG_TYPE;
2083 }
2084 }
2085 }
2086 else {
2087 if((errorcode=readobject(eac->eac_LastKey,&cb,&o))==ERROR_IS_SOFT_LINK) {
2088 errorcode=0;
2089 }
2090 }
2091
2092 while(errorcode==0) {
2093 WORD namelength=strlen(o->name);
2094 WORD keepentry;
2095
2096 stringsize=0;
2097 eadsize=0;
2098
2099 switch(globals->packet->dp_Arg4) {
2100 default:
2101 case ED_OWNER:
2102 eadsize += 4; /* ed_OwnedGID, ed_OwnedUID */
2103 case ED_COMMENT:
2104 stringsize+=strlen(o->name+namelength+1)+1;
2105 eadsize += sizeof(UBYTE *); /* ed_Comment */
2106 case ED_DATE:
2107 eadsize += 12; /* ed_Ticks, ed_Mins, ed_Days */
2108 case ED_PROTECTION:
2109 eadsize += 4; /* ed_Prot */
2110 case ED_SIZE:
2111 eadsize += 4; /* ed_Size */
2112 case ED_TYPE:
2113 eadsize += 4;
2114 case ED_NAME:
2115 stringsize += namelength+1;
2116 eadsize += sizeof(APTR) * 2; /* ed_Name, ed_Next */
2117 break;
2118 }
2119
2120 // _DEBUG(("ACTION_EXAMINE_ALL: eadsize = %ld, stringsize = %ld, spaceleft = %ld, packet->dp_Arg4 = %ld\n",eadsize,stringsize,spaceleft,packet->dp_Arg4));
2121
2122 if(spaceleft<eadsize+stringsize) {
2123 break;
2124 }
2125
2126 switch(globals->packet->dp_Arg4) {
2127 default:
2128 case ED_OWNER:
2129 ead->ed_OwnerUID=BE2W(o->be_owneruid);
2130 ead->ed_OwnerGID=BE2W(o->be_ownergid);
2131 case ED_COMMENT:
2132 {
2133 UBYTE *src=o->name+namelength+1;
2134 UBYTE *dest=(UBYTE *)ead+eadsize;
2135
2136 ead->ed_Comment=dest;
2137
2138 while(*src!=0) {
2139 *dest++=*src++;
2140 eadsize++;
2141 }
2142
2143 *dest=0;
2144 eadsize++;
2145 }
2146 case ED_DATE:
2147 datetodatestamp(BE2L(o->be_datemodified),(struct DateStamp *)&ead->ed_Days);
2148 case ED_PROTECTION:
2149 ead->ed_Prot=BE2L(o->be_protection)^(FIBF_READ|FIBF_WRITE|FIBF_EXECUTE|FIBF_DELETE);
2150 case ED_SIZE:
2151 if((o->bits & OTYPE_DIR)==0) {
2152 ead->ed_Size=BE2L(o->object.file.be_size);
2153 }
2154 else {
2155 ead->ed_Size=0;
2156 }
2157 case ED_TYPE:
2158 _DEBUG(("examine ED_TYPE, o->bits=%x, o->objectnode=%d\n", o->bits, BE2L(o->be_objectnode)));
2159 if((o->bits & OTYPE_LINK)!=0) {
2160 ead->ed_Type=ST_SOFTLINK;
2161 }
2162 if((o->bits & OTYPE_DIR)==0) {
2163 ead->ed_Type=ST_FILE;
2164 }
2165 else if (o->be_objectnode == L2BE(ROOTNODE)) {
2166 ead->ed_Type = ST_ROOT;
2167 }
2168 else {
2169 ead->ed_Type=ST_USERDIR;
2170 }
2171 case ED_NAME:
2172 {
2173 UBYTE *src=o->name;
2174 UBYTE *dest=(UBYTE *)ead+eadsize;
2175
2176 ead->ed_Name=dest;
2177
2178 while(*src!=0) {
2179 *dest++=*src++;
2180 eadsize++;
2181 }
2182
2183 *dest=0;
2184 eadsize++;
2185
2186 // _DEBUG(("Stored entry %s\n",ead->ed_Name));
2187 }
2188 }
2189
2190 if(eac->eac_MatchString!=0) {
2191 keepentry=MatchPatternNoCase(eac->eac_MatchString,ead->ed_Name);
2192 }
2193 else {
2194 keepentry=DOSTRUE;
2195 }
2196
2197 if(keepentry!=DOSFALSE && eac->eac_MatchFunc!=0) {
2198
2199 #ifdef __AROS__
2200 keepentry=CALLHOOKPKT(eac->eac_MatchFunc, ead, (APTR)globals->packet->dp_Arg4);
2201 #else
2202 LONG __asm(*hookfunc)(register __a0 struct Hook *,register __a1 struct ExAllData *,register __a2 ULONG)=(LONG __asm(*)(register __a0 struct Hook *,register __a1 struct ExAllData *,register __a2 ULONG))eac->eac_MatchFunc->h_Entry;
2203 keepentry=hookfunc(eac->eac_MatchFunc,ead,packet->dp_Arg4);
2204 #endif
2205 }
2206
2207 if(keepentry!=DOSFALSE && (o->bits & OTYPE_HIDDEN)==0) {
2208 ead->ed_Next=0;
2209 eadsize = (eadsize + sizeof(APTR) - 1) & ~(sizeof(APTR) - 1);
2210 if(prevead!=0) {
2211 prevead->ed_Next=ead;
2212 }
2213 prevead=ead;
2214 ead=(struct ExAllData *)((UBYTE *)ead+eadsize);
2215 spaceleft-=eadsize;
2216 eac->eac_Entries++;
2217 }
2218
2219 {
2220 struct fsObjectContainer *oc=cb->data;
2221 UBYTE *endadr;
2222
2223 o=nextobject(o);
2224
2225 endadr=(UBYTE *)oc+globals->bytes_block-sizeof(struct fsObject)-2;
2226
2227 if((UBYTE *)o>=endadr || o->name[0]==0) {
2228 if(oc->be_next!=0) {
2229 if((errorcode=readcachebuffercheck(&cb,BE2L(oc->be_next),OBJECTCONTAINER_ID))==0) {
2230 struct fsObjectContainer *oc=cb->data;
2231
2232 o=oc->object;
2233 eac->eac_LastKey=BE2L(o->be_objectnode);
2234 }
2235 }
2236 else {
2237 errorcode=ERROR_NO_MORE_ENTRIES;
2238 }
2239 }
2240 else {
2241 eac->eac_LastKey=BE2L(o->be_objectnode);
2242 }
2243 }
2244 }
2245
2246 if(errorcode!=0) {
2247 returnpacket(DOSFALSE,errorcode);
2248 }
2249 else {
2250 returnpacket(DOSTRUE,0);
2251 }
2252 }
2253 break;
2254 case ACTION_EXAMINE_NEXT:
2255 // _DEBUG(("ACTION_EXAMINE_NEXT(0x%08lx,0x%08lx)\n",BADDR(packet->dp_Arg1),BADDR(packet->dp_Arg2)));
2256
2257 /* An entry is added to a directory in the first dir block with
2258 enough space to hold the entry. If there is no space, then
2259 a new block is added at the START of the directory, and the
2260 new entry is added there.
2261
2262 In the directory block with enough space, the entry is added
2263 at the end of the block. The order of directory entries there
2264 fore is like this (square parenthesis indicate blocks):
2265
2266 [789] [456] [123]
2267
2268 This means we should scan the directory in the exact opposite
2269 order to avoid a trap when an entry is overwritten during
2270 directory scanning (MODE_NEW_FILE removes old entry, and adds
2271 a new one). See below:
2272
2273 1. [123]; scan is at 1 (next = 2); 1 is overwritten.
2274
2275 2. [231]; scan is at 2 (next = 3); 2 is overwritten.
2276
2277 3. [312]; scan is at 3 (next = 1); 3 is overwritten.
2278
2279 4. [123]; same as 1 -> loop!
2280
2281 By scanning the internals of a dir block backwards the problem
2282 is solved:
2283
2284 1. [123]; scan is at 3 (next = 2); 3 is overwritten.
2285
2286 2. [123]; scan is at 2 (next = 1); 2 is overwritten.
2287
2288 3. [132]; scan is at 1 (next = next block); 1 is overwritten.
2289
2290 4. new block is loaded -> no loop. */
2291
2292 {
2293 struct ExtFileLock *lock;
2294 struct CacheBuffer *cb;
2295 struct FileInfoBlock *fib=BADDR(globals->packet->dp_Arg2);
2296 LONG errorcode=0;
2297
2298 lock=(struct ExtFileLock *)BADDR(globals->packet->dp_Arg1);
2299
2300 if(lock==0) {
2301 _DEBUG(("ACTION_EXAMINE_NEXT: Zero lock was passed in...\n"));
2302
2303 returnpacket(DOSFALSE,ERROR_OBJECT_WRONG_TYPE);
2304 break;
2305 }
2306
2307 /*
2308 if(lock->ocblck==0 && lock->ocnode==0) {
2309 _DEBUG(("ACTION_EXAMINE_NEXT: Lock was never passed to EXAMINE_OBJECT or has been re-allocated or the object Examine()d was a file\n"));
2310
2311 returnpacket(DOSFALSE,ERROR_OBJECT_WRONG_TYPE);
2312 break;
2313 }
2314 */
2315
2316 if(lock->currentnode!=0xFFFFFFFF && fib->fib_DiskKey!=lock->currentnode) {
2317 struct fsObject *o;
2318
2319 /* It looks like the lock was reallocated! In this case we must rebuild
2320 the state information in the lock. lock->currentnode, lock->nextnode
2321 and lock->nextnodeblock. */
2322
2323 if((errorcode=readobject(fib->fib_DiskKey, &cb, &o))==0) {
2324 struct fsObjectContainer *oc=cb->data;
2325
2326 lock->currentnode=fib->fib_DiskKey;
2327
2328 if((o=prevobject(o, oc))!=0) {
2329 lock->nextnodeblock=cb->blckno;
2330 lock->nextnode=BE2L(o->be_objectnode);
2331 }
2332 else {
2333 lock->nextnodeblock=BE2L(oc->be_next);
2334 lock->nextnode=0xFFFFFFFF;
2335 }
2336 }
2337 }
2338
2339 if(lock->nextnodeblock==0) {
2340 errorcode=ERROR_NO_MORE_ENTRIES;
2341 }
2342
2343 /* The passed in lock describes a directory. EXAMINE_NEXT should return
2344 this directory's entries one at the time. The lock has state information
2345 which helps determine at which entry we currently are. */
2346
2347 while(errorcode==0 && (errorcode=readcachebuffercheck(&cb, lock->nextnodeblock, OBJECTCONTAINER_ID))==0) {
2348 struct fsObjectContainer *oc=cb->data;
2349 struct fsObject *o=0;
2350 UBYTE bits;
2351
2352 if(lock->nextnode!=0xFFFFFFFF) {
2353 /*** It is possible findobject returns 0... */
2354 o=findobject(oc, lock->nextnode);
2355 }
2356
2357 if(o==0) {
2358 o=lastobject(oc);
2359 }
2360
2361 bits=o->bits;
2362 fillfib(fib, o);
2363 lock->currentnode=BE2L(o->be_objectnode);
2364
2365 /* prepare for another EXAMINE_NEXT */
2366
2367 /* We need to check if there is another object in this ObjectContainer
2368 following the one we just returned. If there is then return its
2369 node. If there isn't then return the next ObjectContainer ptr and
2370 set ocnode to zero. */
2371
2372 if((o=prevobject(o, oc))!=0) {
2373 /* There IS another object */
2374 lock->nextnode=BE2L(o->be_objectnode);
2375 }
2376 else {
2377 lock->nextnodeblock=BE2L(oc->be_next);
2378 lock->nextnode=0xFFFFFFFF;
2379 }
2380
2381 if((bits & OTYPE_HIDDEN)==0) {
2382 break;
2383 }
2384 else if(lock->nextnodeblock==0) {
2385 errorcode=ERROR_NO_MORE_ENTRIES;
2386 break;
2387 }
2388 }
2389
2390 if(errorcode==0) {
2391 returnpacket(DOSTRUE,0);
2392 }
2393 else {
2394 returnpacket(DOSFALSE,errorcode);
2395 }
2396 }
2397 break;
2398 #if 0
2399 /******** OLD EXAMINE_NEXT CODE! */
2400 case ACTION_EXAMINE_NEXT:
2401 // _DEBUG(("ACTION_EXAMINE_NEXT(0x%08lx,0x%08lx)\n",BADDR(packet->dp_Arg1),BADDR(packet->dp_Arg2)));
2402
2403 /* An entry is added to a directory in the first dir block with
2404 enough space to hold the entry. If there is no space, then
2405 a new block is added at the START of the directory, and the
2406 new entry is added there.
2407
2408 In the directory block with enough space, the entry is added
2409 at the end of the block. The order of directory entries there
2410 fore is like this (square parenthesis indicate blocks):
2411
2412 [789] [456] [123]
2413
2414 This means we should scan the directory in the exact opposite
2415 order to avoid a trap when an entry is overwritten during
2416 directory scanning (MODE_NEW_FILE removes old entry, and adds
2417 a new one). See below:
2418
2419 1. [123]; scan is at 1 (next = 2); 1 is overwritten.
2420
2421 2. [231]; scan is at 2 (next = 3); 2 is overwritten.
2422
2423 3. [312]; scan is at 3 (next = 1); 3 is overwritten.
2424
2425 4. [123]; same as 1 -> loop!
2426
2427 By scanning the internals of a dir block backwards the problem
2428 is solved:
2429
2430 1. [123]; scan is at 3 (next = 2); 3 is overwritten.
2431
2432 2. [123]; scan is at 2 (next = 1); 2 is overwritten.
2433
2434 3. [132]; scan is at 1 (next = next block); 1 is overwritten.
2435
2436 4. new block is loaded -> no loop. */
2437
2438 {
2439 struct ExtFileLock *lock;
2440 struct CacheBuffer *cb;
2441 struct FileInfoBlock *fib=BADDR(packet->dp_Arg2);
2442 LONG errorcode=0;
2443
2444 lock=(struct ExtFileLock *)BADDR(packet->dp_Arg1);
2445
2446 if(lock==0) {
2447 _DEBUG(("ACTION_EXAMINE_NEXT: Zero lock was passed in...\n"));
2448
2449 returnpacket(DOSFALSE,ERROR_OBJECT_WRONG_TYPE);
2450 break;
2451 }
2452
2453 /*
2454 if(lock->ocblck==0 && lock->ocnode==0) {
2455 _DEBUG(("ACTION_EXAMINE_NEXT: Lock was never passed to EXAMINE_OBJECT or has been re-allocated or the object Examine()d was a file\n"));
2456
2457 returnpacket(DOSFALSE,ERROR_OBJECT_WRONG_TYPE);
2458 break;
2459 }
2460 */
2461
2462 if(lock->currentnode!=0xFFFFFFFF && fib->fib_DiskKey!=lock->currentnode) {
2463 struct fsObject *o;
2464
2465 /* It looks like the lock was reallocated! In this case we must rebuild
2466 the state information in the lock. lock->currentnode, lock->nextnode
2467 and lock->nextnodeblock. */
2468
2469 if((errorcode=readobject(fib->fib_DiskKey, &cb, &o))==0) {
2470 struct fsObjectContainer *oc=cb->data;
2471
2472 lock->currentnode=fib->fib_DiskKey;
2473
2474 o=nextobject(o);
2475
2476 if(isobject(o,oc)!=FALSE) {
2477 lock->nextnodeblock=cb->blckno;
2478 lock->nextnode=o->objectnode;
2479 }
2480 else {
2481 lock->nextnodeblock=oc->next;
2482 lock->nextnode=0xFFFFFFFF;
2483 }
2484 }
2485 }
2486
2487 if(lock->nextnodeblock==0) {
2488 errorcode=ERROR_NO_MORE_ENTRIES;
2489 }
2490
2491 /* The passed in lock describes a directory. EXAMINE_NEXT should return
2492 this directory's entries one at the time. The lock has state information
2493 which helps determine at which entry we currently are. */
2494
2495 while(errorcode==0 && (errorcode=readcachebuffercheck(&cb,lock->nextnodeblock,OBJECTCONTAINER_ID))==0) {
2496 struct fsObjectContainer *oc=cb->data;
2497 struct fsObject *o=0;
2498 UBYTE bits;
2499
2500 if(lock->nextnode!=0xFFFFFFFF) {
2501 /*** It is possible findobject returns 0... */
2502 o=findobject(oc,lock->nextnode);
2503 }
2504 if(o==0) {
2505 o=oc->object;
2506 }
2507
2508 bits=o->bits;
2509 fillfib(fib,o);
2510 lock->currentnode=o->objectnode;
2511
2512 /* prepare for another EXAMINE_NEXT */
2513
2514 /* We need to check if there is another object in this ObjectContainer
2515 following the one we just returned. If there is then return its
2516 node. If there isn't then return the next ObjectContainer ptr and
2517 set ocnode to zero. */
2518
2519 o=nextobject(o);
2520
2521 if(isobject(o,oc)!=FALSE) {
2522 /* There IS another object */
2523 lock->nextnode=o->objectnode;
2524 }
2525 else {
2526 lock->nextnodeblock=oc->next;
2527 lock->nextnode=0xFFFFFFFF;
2528 }
2529
2530 if((bits & OTYPE_HIDDEN)==0) {
2531 break;
2532 }
2533 else if(lock->nextnodeblock==0) {
2534 errorcode=ERROR_NO_MORE_ENTRIES;
2535 break;
2536 }
2537 }
2538
2539 if(errorcode==0) {
2540 returnpacket(DOSTRUE,0);
2541 }
2542 else {
2543 returnpacket(DOSFALSE,errorcode);
2544 }
2545 }
2546 break;
2547 #endif
2548
2549 case ACTION_EXAMINE_OBJECT:
2550 case ACTION_EXAMINE_FH:
2551 _DEBUG(("ACTION_EXAMINE_OBJECT\n"));
2552
2553 {
2554 struct ExtFileLock *lock;
2555 struct CacheBuffer *cb;
2556 struct fsObject *o;
2557 NODE objectnode;
2558 LONG errorcode;
2559
2560 if(globals->packet->dp_Type==ACTION_EXAMINE_OBJECT) {
2561 lock=(struct ExtFileLock *)BADDR(globals->packet->dp_Arg1);
2562 }
2563 else {
2564 lock=(struct ExtFileLock *)globals->packet->dp_Arg1;
2565 }
2566
2567 if(lock==0) {
2568 objectnode=ROOTNODE;
2569 }
2570 else {
2571 objectnode=lock->objectnode;
2572 }
2573
2574 errorcode=readobject(objectnode,&cb,&o);
2575 if(errorcode==0 || errorcode==ERROR_IS_SOFT_LINK) {
2576 fillfib((struct FileInfoBlock *)BADDR(globals->packet->dp_Arg2),o);
2577
2578 /* prepare for EXAMINE_NEXT */
2579 if(lock!=0 && (o->bits & OTYPE_DIR)!=0) {
2580 lock->currentnode=0xFFFFFFFF;
2581 lock->nextnode=0xFFFFFFFF;
2582 lock->nextnodeblock=BE2L(o->object.dir.be_firstdirblock);
2583 }
2584
2585 returnpacket(DOSTRUE,0);
2586 }
2587 else {
2588 returnpacket(DOSFALSE,errorcode);
2589 }
2590 }
2591
2592 break;
2593 case ACTION_INFO:
2594 _DEBUG(("ACTION_INFO\n"));
2595
2596 {
2597 struct ExtFileLock *lock=BADDR(globals->packet->dp_Arg1);
2598 struct InfoData *id=BADDR(globals->packet->dp_Arg2);
2599
2600 if(lock!=0 && globals->volumenode!=(struct DeviceList *)BADDR(lock->volume)) {
2601 _DEBUG(("ACTION_INFO: returning error\n"));
2602
2603 returnpacket(DOSFALSE,ERROR_DEVICE_NOT_MOUNTED);
2604 break;
2605 }
2606
2607 fillinfodata(id);
2608
2609 returnpacket(DOSTRUE,0);
2610 }
2611 break;
2612 case ACTION_MORE_CACHE:
2613 _DEBUG(("ACTION_MORE_CACHE\n"));
2614
2615 {
2616 LONG errorcode;
2617
2618 errorcode=addcachebuffers(globals->packet->dp_Arg1);
2619 _DEBUG(("ACTION_MORE_CACHE: dp_Arg1 = %ld, totalbuffers = %ld, errorcode = %ld\n",globals->packet->dp_Arg1,globals->totalbuffers,errorcode));
2620
2621 if(errorcode==0) {
2622 // returnpacket(DOSTRUE,totalbuffers);
2623
2624 returnpacket(globals->totalbuffers,0);
2625 }
2626 else {
2627 returnpacket(DOSFALSE,errorcode);
2628 }
2629 }
2630 break;
2631 case ACTION_CHANGE_MODE:
2632 {
2633 struct ExtFileLock *lock=0;
2634 LONG errorcode=0;
2635
2636 if(globals->packet->dp_Arg1==CHANGE_FH) {
2637 lock=(struct ExtFileLock *)((struct FileHandle *)(BADDR(globals->packet->dp_Arg2)))->fh_Arg1;
2638 }
2639 else if(globals->packet->dp_Arg1==CHANGE_LOCK) {
2640 lock=BADDR(globals->packet->dp_Arg2);
2641 }
2642
2643 if(lock!=0) {
2644 if(lock->access!=globals->packet->dp_Arg3) {
2645 if(lock->access!=EXCLUSIVE_LOCK) {
2646 /* Convert shared lock into an exclusive lock. We need to check
2647 if there are no locks besides this one, and that we aren't
2648 trying to get an exclusive lock on the root (which is never
2649 allowed). */
2650
2651 if(lock->objectnode!=ROOTNODE) {
2652 NODE objectnode=lock->objectnode;
2653
2654 lock->objectnode=0; /* this makes sure that our lock is not taken into account by lockable() */
2655
2656 if(lockable(objectnode,EXCLUSIVE_LOCK)!=DOSFALSE) {
2657 /* Lockable says it is possible to lock it exclusively! */
2658
2659 lock->access=EXCLUSIVE_LOCK;
2660 }
2661 else {
2662 errorcode=ERROR_OBJECT_IN_USE;
2663 }
2664
2665 lock->objectnode=objectnode;
2666 }
2667 else {
2668 errorcode=ERROR_OBJECT_IN_USE;
2669 }
2670 }
2671 else {
2672 /* Convert exclusive lock into a shared lock. Should always be
2673 possible. */
2674
2675 lock->access=SHARED_LOCK;
2676 }
2677 }
2678 }
2679 else {
2680 errorcode=ERROR_OBJECT_WRONG_TYPE;
2681 }
2682
2683 if(errorcode==0) {
2684 returnpacket(DOSTRUE,0);
2685 }
2686 else {
2687 returnpacket(DOSFALSE,errorcode);
2688 }
2689 }
2690 break;
2691 case ACTION_PARENT:
2692 case ACTION_PARENT_FH:
2693 _DEBUG(("ACTION_PARENT\n"));
2694
2695 {
2696 LONG errorcode;
2697 struct ExtFileLock *lock;
2698
2699 if(globals->packet->dp_Type==ACTION_PARENT) {
2700 lock=(struct ExtFileLock *)BADDR(globals->packet->dp_Arg1);
2701 }
2702 else {
2703 lock=(struct ExtFileLock *)globals->packet->dp_Arg1;
2704 }
2705
2706 if(lock==0 || lock->objectnode==ROOTNODE) {
2707 returnpacket(0,0);
2708 break;
2709 }
2710
2711 globals->string[0]='/';
2712 globals->string[1]=0;
2713 if((errorcode=lockobject(lock,globals->string,SHARED_LOCK,&lock))!=0) {
2714 returnpacket(0,errorcode);
2715 }
2716 else {
2717 returnpacket((SIPTR)TOBADDR(lock),0);
2718 }
2719 }
2720 break;
2721 case ACTION_COPY_DIR:
2722 case ACTION_COPY_DIR_FH:
2723 _DEBUG(("ACTION_COPY_DIR\n"));
2724
2725 {
2726 LONG errorcode;
2727 struct ExtFileLock *lock;
2728
2729 if(globals->packet->dp_Type==ACTION_COPY_DIR) {
2730 lock=(struct ExtFileLock *)BADDR(globals->packet->dp_Arg1);
2731 }
2732 else {
2733 lock=(struct ExtFileLock *)globals->packet->dp_Arg1;
2734 }
2735
2736 _DEBUG(("ACTION_COPY_DIR: lock=%p\n", lock));
2737
2738 if((errorcode=lockobject(lock,"",SHARED_LOCK,&lock))!=0) {
2739 _DEBUG(("ACTION_COPY_DIR: Failed to obtain lock!\n"));
2740 returnpacket(0,errorcode);
2741 }
2742 else {
2743 returnpacket((SIPTR)TOBADDR(lock),0);
2744 }
2745 }
2746 break;
2747 case ACTION_LOCATE_OBJECT:
2748 {
2749 struct ExtFileLock *lock;
2750 LONG errorcode;
2751
2752 copybstrasstr((BSTR)globals->packet->dp_Arg2,globals->string,258);
2753
2754 _XDEBUG((DEBUG_LOCK,"ACTION_LOCATE_OBJECT(0x%08lx,'%s',0x%08lx)\n",BADDR(globals->packet->dp_Arg1),globals->string,globals->packet->dp_Arg3));
2755
2756 if((errorcode=lockobject((struct ExtFileLock *)BADDR(globals->packet->dp_Arg1),validatepath(globals->string),globals->packet->dp_Arg3,&lock))!=0) {
2757 returnpacket(0,errorcode);
2758 }
2759 else {
2760 returnpacket((SIPTR)TOBADDR(lock),0);
2761 }
2762 }
2763 break;
2764 case ACTION_SFS_LOCATE_OBJECT:
2765 {
2766 struct CacheBuffer *cb;
2767 struct fsObject *o;
2768 struct ExtFileLock *lock=0;
2769 LONG errorcode;
2770
2771 if((errorcode=readobject(globals->packet->dp_Arg1, &cb, &o))==0) {
2772 errorcode=lockobject2(o, globals->packet->dp_Arg2, &lock);
2773 }
2774
2775 if(errorcode!=0) {
2776 returnpacket(0, errorcode);
2777 }
2778 else {
2779 returnpacket((IPTR)lock, 0);
2780 }
2781 }
2782 break;
2783 case ACTION_ADD_NOTIFY:
2784 {
2785 struct NotifyRequest *nr;
2786
2787 nr=(struct NotifyRequest *)globals->packet->dp_Arg1;
2788
2789 nr->nr_Next = (IPTR)globals->notifyrequests;
2790 nr->nr_Prev = 0;
2791 if (globals->notifyrequests)
2792 globals->notifyrequests->nr_Prev = (IPTR)nr;
2793 globals->notifyrequests = nr;
2794
2795 _DEBUG(("ACTION_ADD_NOTIFY: Starting notification on %s (flags 0x%08lx)\n",nr->nr_FullName,nr->nr_Flags));
2796
2797 if((nr->nr_Flags & NRF_NOTIFY_INITIAL)!=0) {
2798 notify(nr);
2799 }
2800
2801 returnpacket(DOSTRUE,0);
2802 }
2803 break;
2804 case ACTION_REMOVE_NOTIFY:
2805 {
2806 struct NotifyRequest *nr;
2807
2808 nr=(struct NotifyRequest *)globals->packet->dp_Arg1;
2809
2810 _DEBUG(("ACTION_REMOVE_NOTIFY: Removing notification of %s\n",nr->nr_FullName));
2811
2812 if((nr->nr_Flags & NRF_SEND_MESSAGE) != 0) {
2813 /* Removing all outstanding messages form msgport */
2814 while(GetMsg(nr->nr_stuff.nr_Msg.nr_Port)!=0) {
2815 }
2816 nr->nr_MsgCount=0;
2817 }
2818
2819 if(nr->nr_Prev)
2820 ((struct NotifyRequest *)nr->nr_Prev)->nr_Next = nr->nr_Next;
2821 else
2822 globals->notifyrequests = (struct NotifyRequest *)nr->nr_Next;
2823
2824 if (nr->nr_Next)
2825 ((struct NotifyRequest *)nr->nr_Next)->nr_Prev = nr->nr_Prev;
2826
2827 nr->nr_Next = 0;
2828 nr->nr_Prev = 0;
2829
2830 returnpacket(DOSTRUE,0);
2831 }
2832 break;
2833 case ACTION_FLUSH:
2834 {
2835 LONG errorcode;
2836
2837 if((errorcode=flushcaches())==0) {
2838 returnpacket(DOSTRUE, 0);
2839 }
2840 else {
2841 returnpacket(DOSFALSE, errorcode);
2842 }
2843 }
2844 break;
2845 case ACTION_SFS_READ_BITMAP:
2846 {
2847 LONG errorcode;
2848
2849 Forbid();
2850 Permit();
2851
2852 errorcode=extractspace((UBYTE *)globals->packet->dp_Arg1, globals->packet->dp_Arg2, globals->packet->dp_Arg3);
2853
2854 returnpacket(errorcode==0 ? DOSTRUE : DOSFALSE, errorcode);
2855 }
2856 break;
2857 case ACTION_SFS_DEFRAGMENT_INIT:
2858 {
2859 globals->block_defragptr=2;
2860
2861 returnpacket(DOSTRUE, 0);
2862 }
2863 break;
2864 case ACTION_SFS_DEFRAGMENT_STEP:
2865 {
2866 LONG errorcode;
2867
2868 globals->defragmentsteps=(ULONG *)globals->packet->dp_Arg1;
2869 globals->defragmentlongs=globals->packet->dp_Arg2 - 2;
2870
2871 if(globals->defragmentsteps!=0) {
2872 *globals->defragmentsteps=0;
2873 }
2874
2875 while((errorcode=flushtransaction())!=0 && req("Pending buffers couldn't be flushed\nto the disk before defragmentation\nbecause of error %ld.", "Retry|Cancel", errorcode)==1) {
2876 }
2877
2878 if(errorcode==0) {
2879
2880 newtransaction();
2881
2882 if((errorcode=step())!=0) {
2883 deletetransaction();
2884 }
2885 else {
2886 endtransaction();
2887
2888 while((errorcode=flushtransaction())!=0 && req("Pending buffers couldn't be flushed\nto the disk during defragmentation\nbecause of error %ld.", "Retry|Cancel", errorcode)==1) {
2889 }
2890 }
2891 }
2892
2893 if(errorcode==0) {
2894 struct DefragmentStep *ds=(struct DefragmentStep *)globals->packet->dp_Arg1;
2895
2896 while(ds->id!=0) {
2897 if(ds->id==AROS_LONG2BE(MAKE_ID('M','O','V','E')) && ds->length==3) {
2898 updatelocksaftermove(ds->data[1], ds->data[2], ds->data[0]);
2899 }
2900 ds=(struct DefragmentStep *)((ULONG *)ds + 2 + ds->length);
2901 }
2902
2903 returnpacket(DOSTRUE, 0);
2904 }
2905 else {
2906 returnpacket(DOSFALSE, errorcode);
2907 }
2908 }
2909 break;
2910 default:
2911 _DEBUG(("ERROR_ACTION_NOT_KNOWN (packettype = %ld)\n",globals->packet->dp_Type));
2912 returnpacket(DOSFALSE,ERROR_ACTION_NOT_KNOWN);
2913 break;
2914 }
2915 }
2916 else if(globals->disktype==ID_NO_DISK_PRESENT) {
2917 dumppackets(globals->packet,ERROR_NO_DISK);
2918 }
2919 else {
2920 dumppackets(globals->packet,ERROR_NOT_A_DOS_DISK);
2921 }
2922 }
2923 break;
2924 }
2925 }
2926 } while(msg!=0);
2927 }
2928 }
2929
2930
2931
2932 static void fillfib(struct FileInfoBlock *fib,struct fsObject *o)
2933 {
2934 UBYTE *src;
2935 UBYTE *dest;
2936 UBYTE length;
2937
2938 if (o->be_objectnode==L2BE(ROOTNODE)) {
2939 fib->fib_DirEntryType=ST_ROOT;
2940 fib->fib_Size=BE2L(o->object.file.be_size);
2941 fib->fib_NumBlocks=(BE2L(o->object.file.be_size)+globals->bytes_block-1) >> globals->shifts_block;
2942 } else if((o->bits & OTYPE_LINK)!=0) {
2943 fib->fib_DirEntryType=ST_SOFTLINK;
2944 // fib->fib_DirEntryType=ST_USERDIR; // For compatibility with Diavolo 3.4 -> screw it, DOpus fails...
2945 fib->fib_Size=BE2L(o->object.file.be_size);
2946 fib->fib_NumBlocks=0;
2947 }
2948 else if((o->bits & OTYPE_DIR)==0) {
2949 fib->fib_DirEntryType=ST_FILE;
2950 fib->fib_Size=BE2L(o->object.file.be_size);
2951 fib->fib_NumBlocks=(BE2L(o->object.file.be_size)+globals->bytes_block-1) >> globals->shifts_block;
2952 }
2953 else {
2954 fib->fib_DirEntryType=ST_USERDIR;
2955 fib->fib_Size=0;
2956 fib->fib_NumBlocks=1;
2957 }
2958 fib->fib_Protection=BE2L(o->be_protection)^(FIBF_READ|FIBF_WRITE|FIBF_EXECUTE|FIBF_DELETE);
2959 fib->fib_EntryType=fib->fib_DirEntryType;
2960 fib->fib_DiskKey=BE2L(o->be_objectnode);
2961 fib->fib_OwnerUID=BE2W(o->be_owneruid);
2962 fib->fib_OwnerGID=BE2W(o->be_ownergid);
2963 datetodatestamp(BE2L(o->be_datemodified),&fib->fib_Date);
2964
2965 src=o->name;
2966 dest = fib->fib_FileName;
2967 dest++;
2968 length=0;
2969
2970 while(*src!=0) {
2971 *dest++=*src++;
2972 length++;
2973 }
2974 fib->fib_FileName[0]=length;
2975
2976 src++; /* comment follows name, so just skip the null-byte seperating them */
2977
2978 dest = fib->fib_Comment;
2979 dest++;
2980 length=0;
2981
2982 while(*src!=0) {
2983 *dest++=*src++;
2984 length++;
2985 }
2986 fib->fib_Comment[0]=length;
2987 }
2988
2989
2990
2991 static struct DosPacket *getpacket(struct Process *p) {
2992 struct MsgPort *port=&p->pr_MsgPort; /* get port of our process */
2993 struct Message *msg;
2994
2995 if((msg=GetMsg(port))!=0) {
2996 return((struct DosPacket *)msg->mn_Node.ln_Name);
2997 }
2998 else {
2999 return(0);
3000 }
3001 }
3002
3003
3004
3005 static struct DosPacket *waitpacket(struct Process *p) {
3006 struct MsgPort *port=&p->pr_MsgPort; /* get port of our process */
3007 struct Message *msg;
3008
3009 WaitPort(port);
3010
3011 msg=GetMsg(port);
3012
3013 return((struct DosPacket *)msg->mn_Node.ln_Name);
3014 }
3015
3016
3017
3018 static void returnpacket(SIPTR res1,LONG res2) {
3019 struct Message *msg;
3020 struct MsgPort *replyport;
3021
3022 globals->packet->dp_Res1=res1; /* set return codes */
3023 globals->packet->dp_Res2=res2;
3024
3025 replyport=globals->packet->dp_Port; /* Get ReplyPort */
3026
3027 msg=globals->packet->dp_Link; /* Pointer to the Exec-Message of the packet */
3028
3029 globals->packet->dp_Port=&globals->mytask->pr_MsgPort; /* Setting Packet-Port back */
3030
3031 msg->mn_Node.ln_Name=(char *)globals->packet; /* Connect Message and Packet */
3032 msg->mn_Node.ln_Succ=NULL;
3033 msg->mn_Node.ln_Pred=NULL;
3034
3035 PutMsg(replyport,msg); /* Send the Message */
3036 }
3037
3038
3039
3040 static void returnpacket2(struct DosPacket *packet, SIPTR res1, LONG res2)
3041 {
3042 struct Message *msg;
3043 struct MsgPort *replyport;
3044
3045 D(bug("[SFS] Replying, results are %ld/%ld\n", res1, res2));
3046
3047 packet->dp_Res1=res1; /* set return codes */
3048 packet->dp_Res2=res2;
3049
3050 replyport=packet->dp_Port; /* Get ReplyPort */
3051
3052 msg=packet->dp_Link; /* Pointer to the Exec-Message of the packet */
3053
3054 packet->dp_Port=&globals->mytask->pr_MsgPort; /* Setting Packet-Port back */
3055
3056 msg->mn_Node.ln_Name=(char *)packet; /* Connect Message and Packet */
3057 msg->mn_Node.ln_Succ=NULL;
3058 msg->mn_Node.ln_Pred=NULL;
3059
3060 PutMsg(replyport,msg); /* Send the Message */
3061 }
3062
3063
3064
3065 void starttimeout() {
3066 /* From the AbortIO AutoDocs:
3067 iORequest - pointer to an I/O request block (must have been used
3068 at least once. May be active or finished). */
3069
3070 if(globals->pendingchanges==FALSE) {
3071 globals->inactivitytimer_ioreq->tr_time.tv_secs=globals->inactivity_timeout/2;
3072 globals->inactivitytimer_ioreq->tr_time.tv_micro=(globals->inactivity_timeout*500000)%1000000;
3073 globals->inactivitytimer_ioreq->tr_node.io_Command=TR_ADDREQUEST;
3074
3075 SendIO(&globals->inactivitytimer_ioreq->tr_node);
3076
3077 globals->pendingchanges=TRUE;
3078 globals->timerreset=FALSE;
3079 }
3080 else {
3081 globals->timerreset=TRUE; /* Indicates that during the timeout there was another request. */
3082 }
3083
3084 if(globals->activitytimeractive==FALSE) {
3085 globals->activitytimer_ioreq->tr_time.tv_secs=globals->activity_timeout;
3086 globals->activitytimer_ioreq->tr_time.tv_micro=0;
3087 globals->activitytimer_ioreq->tr_node.io_Command=TR_ADDREQUEST;
3088
3089 SendIO(&globals->activitytimer_ioreq->tr_node);
3090
3091 globals->activitytimeractive=TRUE;
3092 }
3093 }
3094
3095
3096
3097 void stoptimeout(void) {
3098
3099 if(globals->pendingchanges!=FALSE) {
3100 AbortIO(&globals->inactivitytimer_ioreq->tr_node);
3101 WaitIO(&globals->inactivitytimer_ioreq->tr_node);
3102
3103 globals->pendingchanges=FALSE;
3104 globals->timerreset=FALSE;
3105 }
3106
3107 // if(activitytimeractive!=FALSE) {
3108 // AbortIO(&activitytimer_ioreq->tr_node);
3109 // WaitIO(&activitytimer_ioreq->tr_node);
3110 //
3111 // activitytimeractive=FALSE;
3112 // }
3113 }
3114
3115
3116
3117 LONG flushcaches() {
3118 LONG errorcode;
3119
3120 /* Flushes any pending changes to disk and ask the user what to do when
3121 an error occurs. */
3122
3123 while((errorcode=flushtransaction())!=0 && req("Pending buffers couldn't be flushed\nto the disk because of error %ld.", "Retry|Cancel", errorcode)==1) {
3124 }
3125
3126 motoroff();
3127
3128 return(errorcode);
3129 }
3130
3131
3132
3133 void invalidatecaches() {
3134
3135 /* Invalidates all caches without flushing. Call flushcaches()
3136 first. */
3137
3138 invalidatecachebuffers();
3139 invalidateiocaches();
3140 }
3141
3142
3143 void dreqArgs(UBYTE *fmt, APTR params)
3144 {
3145 APTR args[4];
3146 UBYTE *fmt2;
3147
3148 if(globals->debugreqs!=FALSE) {
3149 args[0]=AROS_BSTR_ADDR(globals->devnode->dn_Name);
3150 args[1]=AROS_BSTR_ADDR(globals->startupmsg->fssm_Device);
3151 args[2]=(APTR)globals->startupmsg->fssm_Unit;
3152 args[3]=fmt;
3153
3154 if((fmt2=AllocVec(strlen(fmt)+100,0))!=0) {
3155 _DEBUG(("\nREQUESTER\n\n"));
3156 RawDoFmt("SmartFilesystem %s: (%s, unit %ld)\n\n%s",args,putChFunc,fmt2);
3157
3158 if (requestArgs(PROGRAMNAME, fmt2, "Continue|No more requesters", params) == 0)
3159 globals->debugreqs=FALSE;
3160
3161 FreeVec(fmt2);
3162 }
3163 }
3164 }
3165
3166 LONG reqArgs(UBYTE *fmt, UBYTE *gads, APTR params)
3167 {
3168 APTR args[5];
3169 APTR *arg=args;
3170 UBYTE *fmt2;
3171 LONG gadget=0;
3172
3173 /* Simple requester function. It will put up a requester
3174 in the form of:
3175
3176 "Volume 'BOOT' (DH0: scsi.device, unit 0)"
3177
3178 or:
3179
3180 "Device DH0: (scsi.device, unit 0)"
3181
3182 This depends on whether or not there is a valid
3183 VolumeNode. */
3184
3185 if(globals->volumenode!=0) {
3186 *arg++=AROS_BSTR_ADDR(globals->volumenode->dl_Name);
3187 }
3188
3189 *arg++=AROS_BSTR_ADDR(globals->devnode->dn_Name);
3190 *arg++=AROS_BSTR_ADDR(globals->startupmsg->fssm_Device);
3191 *arg++=(APTR)globals->startupmsg->fssm_Unit;
3192 *arg=fmt;
3193
3194 if((fmt2=AllocVec(strlen(fmt)+100,0))!=0) {
3195
3196 if(globals->volumenode!=0) {
3197 RawDoFmt("Volume '%s' (%s: %s, unit %ld)\n\n%s",args,putChFunc,fmt2);
3198 }
3199 else {
3200 RawDoFmt("Device %s: (%s, unit %ld)\n\n%s",args,putChFunc,fmt2);
3201 }
3202
3203 gadget = requestArgs(PROGRAMNAME " request", fmt2, gads, params);
3204 FreeVec(fmt2);
3205 }
3206
3207 return(gadget);
3208 }
3209
3210 LONG req_unusualArgs(UBYTE *fmt, APTR params)
3211 {
3212 APTR args[5];
3213 UBYTE *fmt2;
3214 LONG gadget=0;
3215
3216 /* Simple requester function. */
3217 args[0]=AROS_BSTR_ADDR(globals->devnode->dn_Name);
3218 args[1]=AROS_BSTR_ADDR(globals->startupmsg->fssm_Device);
3219 args[2]=(APTR)globals->startupmsg->fssm_Unit;
3220 args[3]=fmt;
3221 args[4]="This is a safety check requester, which should\n"\
3222 "never appear under normal conditions. Please\n"\
3223 "notify the author about the error above and if\n"\
3224 "possible under what circumstances it appeared.\n\n"\
3225 "BEWARE: SFS might crash if you click Continue.\n"\
3226 " Please save your work first!";
3227
3228 if((fmt2=AllocVec(strlen(fmt)+400,0))!=0) {
3229
3230 RawDoFmt("SmartFilesystem %s: (%s, unit %ld)\n\n%s\n\n%s",args,putChFunc,fmt2);
3231 gadget = requestArgs(PROGRAMNAME " request", fmt2, "Continue", params);
3232 FreeVec(fmt2);
3233 }
3234
3235 return(gadget);
3236 }
3237
3238 void request2(UBYTE *text) {
3239 request(PROGRAMNAME, text, "Ok", 0);
3240 }
3241
3242 LONG requestArgs(UBYTE *title, UBYTE *fmt, UBYTE *gads, APTR params)
3243 {
3244 struct EasyStruct es;
3245
3246 es.es_StructSize=sizeof(struct EasyStruct);
3247 es.es_Flags=0;
3248 es.es_Title=title;
3249 es.es_TextFormat=fmt;
3250 es.es_GadgetFormat=gads;
3251
3252 return EasyRequestArgs(0, &es, 0, params);
3253 }
3254
3255 void outputcachebuffer(struct CacheBuffer *cb) {
3256 ULONG *a;
3257 UWORD n;
3258
3259 _DEBUG(("CacheBuffer at address 0x%08lx of block %ld (Locked = %ld, Bits = 0x%02lx)\n",cb,cb->blckno,(LONG)cb->locked,(LONG)cb->bits));
3260
3261 a=cb->data;
3262
3263 for(n=0; n<(globals->bytes_block>>5); n++) {
3264 _DEBUG(("%08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]));
3265 a+=8;
3266 }
3267 }
3268
3269
3270
3271
3272 LONG readroots(void)
3273 {
3274 struct CacheBuffer *cb1;
3275 struct CacheBuffer *cb2;
3276 struct fsRootBlock *rb1;
3277 struct fsRootBlock *rb2;
3278 WORD rb1okay=TRUE;
3279 WORD rb2okay=TRUE;
3280 UQUAD first, last;
3281 LONG errorcode;
3282
3283 if((errorcode=readcachebuffer(&cb1,0))!=0) {
3284 return(errorcode);
3285 }
3286
3287 lockcachebuffer(cb1);
3288
3289 if((errorcode=readcachebuffer(&cb2,globals->blocks_total-1))!=0) {
3290 unlockcachebuffer(cb1);
3291 return(errorcode);
3292 }
3293
3294 unlockcachebuffer(cb1);
3295
3296 rb1=cb1->data;
3297 rb2=cb2->data;
3298
3299 if(checkchecksum(cb1)==DOSFALSE || rb1->bheader.id!=L2BE(DOSTYPE_ID) || rb1->bheader.be_ownblock!=0) {
3300 _DEBUG(("cb1/rb1 not ok!\n"));
3301 rb1okay=FALSE;
3302 }
3303
3304 _DEBUG(("checkchecksum(cb1)=%d, rb1->bheader.id=%08x (wanted %08x), rb1->bheader.ownblock=%d\n",
3305 checkchecksum(cb1),BE2L(rb1->bheader.id), DOSTYPE_ID, BE2L(rb1->bheader.be_ownblock)
3306 ));
3307
3308 if(checkchecksum(cb2)==DOSFALSE || rb2->bheader.id!=L2BE(DOSTYPE_ID) || BE2L(rb2->bheader.be_ownblock)!=BE2L(rb2->be_totalblocks)-1) {
3309 _DEBUG(("cb2/rb2 not ok!\n"));
3310 rb2okay=FALSE;
3311 }
3312
3313 _DEBUG(("checkchecksum(cb2)=%d, rb2->bheader.id=%08x, rb2->bheader.ownblock=%d, rb2->be_totalblocks =%d\n",
3314 checkchecksum(cb2),BE2L(rb2->bheader.id), BE2L(rb2->bheader.be_ownblock), BE2L(rb2->be_totalblocks)
3315 ));
3316
3317 if(rb1okay!=FALSE && rb2okay!=FALSE) {
3318 /* Both root blocks look okay. */
3319
3320 /*
3321 if(rb1->sequencenumber!=rb2->sequencenumber) {
3322 // Sequence numbers differ!
3323 }
3324 */
3325
3326 /* Check sizes stored in rootblock */
3327 if ((rb1->be_blocksize != L2BE(globals->bytes_block)) || (rb1->be_totalblocks!=L2BE(globals->blocks_total)))
3328 {
3329 _DEBUG(("bad size in rb1!\n"));
3330 return(ERROR_NOT_A_DOS_DISK);
3331 }
3332
3333 /*
3334 * Historically SFS rootblock holds absolute start and end positions on the disk in bytes.
3335 * They are used for validation and nothing else.
3336 * However, a situation is possible when for example someone takes an image of SFS partition
3337 * and then tries to mount it.
3338 * In order to make it working we compare lengths, not positions. If length is okay, the rootblock
3339 * is assumed to be okay.
3340 */
3341 first = ((UQUAD)BE2L(rb1->be_firstbyteh) << 32) | BE2L(rb1->be_firstbyte);
3342 last = ((UQUAD)BE2L(rb1->be_lastbyteh) << 32) | BE2L(rb1->be_lastbyte);
3343
3344 if (last - first != globals->byte_high - globals->byte_low)
3345 {
3346 _DEBUG(("bad value in rb1!\n"));
3347 return ERROR_NOT_A_DOS_DISK;
3348 }
3349
3350 if(rb1->be_version!=BE2W(STRUCTURE_VERSION)) {
3351 /* Different version! */
3352
3353 request(PROGRAMNAME " request","%s\n"\
3354 "is in a format unsupported by this version\n"\
3355 "of the filesystem. Please reformat the disk or\n"\
3356 "install the correct version of this filesystem.",
3357 "Ok",AROS_BSTR_ADDR(globals->devnode->dn_Name));
3358
3359 return(ERROR_NOT_A_DOS_DISK);
3360 }
3361
3362 globals->block_bitmapbase=BE2L(rb1->be_bitmapbase);
3363 globals->block_adminspace=BE2L(rb1->be_adminspacecontainer);
3364 globals->block_root=BE2L(rb1->be_rootobjectcontainer);
3365 globals->block_extentbnoderoot=BE2L(rb1->be_extentbnoderoot);
3366 globals->block_objectnoderoot=BE2L(rb1->be_objectnoderoot);
3367
3368 if((rb1->bits & ROOTBITS_CASESENSITIVE)!=0) {
3369 globals->is_casesensitive=TRUE;
3370 }
3371 else {
3372 globals->is_casesensitive=FALSE;
3373 }
3374
3375 if((rb1->bits & ROOTBITS_RECYCLED)!=0) {
3376 globals->has_recycled=TRUE;
3377 }
3378 else {
3379 globals->has_recycled=FALSE;
3380 }
3381 }
3382 else {
3383 errorcode=ERROR_NOT_A_DOS_DISK;
3384 }
3385
3386 return(errorcode);
3387 }
3388
3389
3390
3391 struct DeviceList *usevolumenode(UBYTE *name, ULONG creationdate) {
3392 struct DosList *dol;
3393 struct DeviceList *vn=0;
3394
3395 /* This function locates the specified volumenode, and if found
3396 uses it for the current volume inserted. If the node is not
3397 found this function returns 0. If the specified volumenode
3398 is found, but is found to be in use, then this function
3399 returns -1. Otherwise the found volumenode is returned. */
3400
3401 dol=LockDosList(LDF_READ|LDF_VOLUMES);
3402
3403 while((dol=FindDosEntry(dol, name, LDF_VOLUMES))!=0) {
3404 if(datestamptodate(&dol->dol_misc.dol_volume.dol_VolumeDate)==creationdate) { // Do volumes have same creation date?
3405 Forbid();
3406 if(dol->dol_misc.dol_volume.dol_LockList!=0 || ((struct DeviceList *)dol)->dl_unused!=0) { // Is volume not in use?
3407 struct NotifyRequest *nr;
3408 struct ExtFileLock *lock;
3409
3410 /* Volume is not currently in use, so grab locklist & notifyrequests and patch fl_Task fields */
3411
3412 _DEBUG(("usevolumenode: Found DosEntry with same date, and locklist!=0\n"));
3413
3414 lock=(struct ExtFileLock *)BADDR(dol->dol_misc.dol_volume.dol_LockList);
3415 nr=(struct NotifyRequest *)BADDR((((struct DeviceList *)dol)->dl_unused));
3416 dol->dol_misc.dol_volume.dol_LockList=0;
3417 ((struct DeviceList *)dol)->dl_unused=0;
3418
3419 Permit();
3420
3421 globals->locklist=lock;
3422 globals->notifyrequests=nr;
3423
3424 while(lock!=0) {
3425 lock->task=&globals->mytask->pr_MsgPort;
3426 lock=lock->next;
3427 }
3428
3429 while(nr!=0) {
3430 nr->nr_Handler=&globals->mytask->pr_MsgPort;
3431 nr = (struct NotifyRequest *)nr->nr_Next;
3432 }
3433
3434 vn=(struct DeviceList *)dol;
3435 break;
3436 }
3437 else {
3438 Permit();
3439
3440 _DEBUG(("usevolumenode: Found DosEntry with same date, but it is in use!\n"));
3441
3442 vn=(struct DeviceList *)-1;
3443 }
3444 }
3445
3446 /* Volume nodes are of different date, continue search */
3447 dol=NextDosEntry(dol, LDF_VOLUMES);
3448 }
3449
3450 UnLockDosList(LDF_READ|LDF_VOLUMES);
3451
3452 return(vn);
3453 }
3454
3455
3456
3457 LONG initdisk() {
3458
3459 /* This routine is called whenever a disk has changed (via ACTION_INHIBIT or
3460 on startup). The routine scans the disk and initializes the necessary
3461 variables. Steps:
3462
3463 - Check if the disk is a valid DOS disk
3464 If so, get name and datestamp of the disk
3465 If valid, look for volume node of the same name and datestamp
3466 If so, retrieve locklist from dol_LockList (fix fl_Task fields!)
3467 and use existing volume node.
3468 If not, a new volume node is created.
3469 If the disk carries the same attributes as another ACTIVE volume
3470 the handler ignores the newly inserted volume.
3471 If not valid, R/W error requester -> "NDOS"
3472 If not valid type is "NDOS"
3473
3474 */
3475
3476 changegeometry(globals->dosenvec);
3477
3478 if(globals->volumenode==0) {
3479 struct CacheBuffer *cb;
3480 struct fsObjectContainer *oc=0;
3481 ULONG newdisktype;
3482 LONG errorcode;
3483
3484 globals->diskstate=writeprotection();
3485
3486 if((errorcode=readroots())==0) {
3487
3488 /* Root blocks are valid for this filesystem */
3489
3490 _DEBUG(("Initdisk: Root blocks read\n"));
3491
3492 #ifdef STARTDEBUG
3493 dreq("Root blocks are okay!");
3494 #endif
3495
3496 if((errorcode=checkfortransaction())==0) {
3497
3498 _DEBUG(("Initdisk: Checked for an old Transaction and applied it if it was present.\n"));
3499
3500 if((errorcode=readcachebuffercheck(&cb,globals->block_root,OBJECTCONTAINER_ID))==0) {
3501 struct fsRootInfo *ri=(struct fsRootInfo *)((UBYTE *)cb->data+globals->bytes_block-sizeof(struct fsRootInfo));
3502 ULONG blocksfree=0;
3503
3504 lockcachebuffer(cb);
3505 oc=cb->data;
3506
3507 _DEBUG(("Initdisk: '%s' was inserted\n",oc->object[0].name));
3508
3509 /* ROOT block is valid for this filesystem */
3510
3511 /* We should count the number of set bits in the bitmap now */
3512
3513 {
3514 struct CacheBuffer *cb;
3515 struct fsBitmap *b;
3516 BLCK bitmapblock=globals->block_bitmapbase;
3517 UWORD cnt=globals->blocks_bitmap;
3518 WORD n;
3519
3520 while(cnt-->0 && (errorcode=readcachebuffercheck(&cb,bitmapblock,BITMAP_ID))==0) {
3521 b=cb->data;
3522
3523 for(n=0; n<((globals->bytes_block-sizeof(struct fsBitmap))>>2); n++) {
3524 if(b->bitmap[n]!=0) {
3525 if(b->bitmap[n]==0xFFFFFFFF) {
3526 blocksfree+=32;
3527 }
3528 else {
3529 blocksfree+=bfcnto(b->bitmap[n]);
3530 }
3531 }
3532 }
3533 bitmapblock++;
3534 }
3535 }
3536
3537 unlockcachebuffer(cb);
3538
3539 _DEBUG(("Initdisk: Traversed bitmap, found %ld free blocks\n",blocksfree));
3540
3541 if(errorcode==0 && BE2L(ri->be_freeblocks)!=blocksfree) {
3542 if(ri->be_freeblocks!=0) {
3543 dreq("The number of free blocks (%ld) is incorrect.\n"\
3544 "According to the bitmap it should be %ld.\n"\
3545 "The number of free blocks will now be updated.", BE2L(ri->be_freeblocks), blocksfree);
3546 }
3547
3548 newtransaction();
3549
3550 preparecachebuffer(cb);
3551
3552 ri->be_freeblocks=L2BE(blocksfree);
3553
3554 if((errorcode=storecachebuffer(cb))==0) {
3555 endtransaction();
3556 }
3557 else {
3558 deletetransaction();
3559 }
3560 }
3561
3562 if(errorcode==0) {
3563 _DEBUG(("Initdisk: A valid DOS disk\n"));
3564
3565 newdisktype = DOSTYPE_ID;
3566
3567 #ifdef STARTDEBUG
3568 dreq("There is a valid SFS disk present!");
3569 #endif
3570 }
3571 else {
3572
3573 #ifdef STARTDEBUG
3574 dreq("SFS disk is invalid; bitmap error.");
3575 #endif
3576
3577 newdisktype=ID_NOT_REALLY_DOS;
3578 errorcode=ERROR_NOT_A_DOS_DISK;
3579 }
3580 }
3581 else {
3582
3583 #ifdef STARTDEBUG
3584 dreq("SFS disk is invalid; root objectcontainer error.");
3585 #endif
3586
3587 newdisktype=ID_NOT_REALLY_DOS;
3588 errorcode=ERROR_NOT_A_DOS_DISK;
3589 }
3590 }
3591 else {
3592
3593 #ifdef STARTDEBUG
3594 dreq("SFS disk is invalid; transaction error.");
3595 #endif
3596
3597 newdisktype=ID_NOT_REALLY_DOS;
3598 errorcode=ERROR_NOT_A_DOS_DISK;
3599 }
3600 }
3601 else if(errorcode==INTERR_CHECKSUM_FAILURE || errorcode==ERROR_NOT_A_DOS_DISK) {
3602 newdisktype=ID_NOT_REALLY_DOS;
3603 errorcode=ERROR_NOT_A_DOS_DISK;
3604
3605 #ifdef STARTDEBUG
3606 dreq("SFS disk is invalid; checksum failure.");
3607 #endif
3608 }
3609 else if(errorcode==INTERR_BLOCK_WRONG_TYPE) {
3610 #ifdef STARTDEBUG
3611 dreq("SFS disk is invalid; wrong block type.");
3612 #endif
3613
3614 newdisktype=ID_NOT_REALLY_DOS;
3615 errorcode=ERROR_NOT_A_DOS_DISK;
3616 }
3617 else if(errorcode==TDERR_DiskChanged) {
3618 #ifdef STARTDEBUG
3619 dreq("SFS disk is invalid; disk was changed.");
3620 #endif
3621
3622 newdisktype=ID_NO_DISK_PRESENT;
3623 errorcode=ERROR_NO_DISK;
3624 }
3625 else {
3626 #ifdef STARTDEBUG
3627 dreq("SFS disk is invalid; unreadable disk.");
3628 #endif
3629
3630 newdisktype=ID_UNREADABLE_DISK;
3631 errorcode=ERROR_NOT_A_DOS_DISK;
3632 }
3633
3634 if(errorcode==0) {
3635 struct DeviceList *vn;
3636 struct fsRootInfo *ri=(struct fsRootInfo *)((UBYTE *)oc+globals->bytes_block-sizeof(struct fsRootInfo));
3637
3638 _DEBUG(("initdisk: Checking for an existing volume-node\n"));
3639
3640 if((vn=usevolumenode(oc->object[0].name, BE2L(ri->be_datecreated)))!=(struct DeviceList *)-1) {
3641 if(vn==0) {
3642 /* VolumeNode was not found, so we need to create a new one. */
3643
3644 _DEBUG(("initdisk: No volume-node found, creating new one instead.\n"));
3645
3646 if((vn=(struct DeviceList *)MakeDosEntry(" ",DLT_VOLUME))!=0) {
3647 struct SFSMessage *sfsm;
3648 UBYTE *d2=(UBYTE *)BADDR(vn->dl_Name);
3649 #ifdef AROS_FAST_BSTR
3650 copystr(oc->object[0].name, d2, 30);
3651 #else
3652 UBYTE *d=d2+1;
3653 UBYTE *s=oc->object[0].name;
3654 UBYTE len=0;
3655
3656 while(*s!=0 && len<30) {
3657 *d++=*s++;
3658 len++;
3659 }
3660
3661 *d=0;
3662 *d2=len;
3663 #endif
3664
3665 datetodatestamp(BE2L(ri->be_datecreated), &vn->dl_VolumeDate);
3666
3667 _DEBUG(("initdisk: Sending msg.\n"));
3668
3669 if((sfsm=AllocVec(sizeof(struct SFSMessage), MEMF_CLEAR))!=0) {
3670 sfsm->command=SFSM_ADD_VOLUMENODE;
3671 sfsm->data=(IPTR)vn;
3672 sfsm->msg.mn_Length=sizeof(struct SFSMessage);
3673
3674 PutMsg(globals->sdlhport, (struct Message *)sfsm);
3675 }
3676 }
3677 else {
3678 errorcode=ERROR_NO_FREE_STORE;
3679 }
3680 }
3681
3682 _DEBUG(("initdisk: Using new or old volumenode.\n"));
3683
3684 if(errorcode==0) { /* Reusing the found VolumeNode or using the new VolumeNode */
3685 vn->dl_Task=globals->devnode->dn_Task;
3686 vn->dl_DiskType=globals->dosenvec->de_DosType;
3687 globals->volumenode=vn;
3688 }
3689 }
3690 else { /* Volume is in use by another handler -- stay off */
3691 _DEBUG(("Initdisk: Found DosEntry with same date, and locklist==0\n"));
3692 newdisktype=ID_NO_DISK_PRESENT; /* Hmmm... EXTREMELY unlikely, but may explain the strange bug Laire had. */
3693 errorcode=ERROR_NO_DISK;
3694 // vn=0;
3695 globals->volumenode=0;
3696 }
3697 }
3698
3699 if(errorcode==0) {
3700 diskchangenotify(IECLASS_DISKINSERTED);
3701 }
3702
3703 globals->disktype=newdisktype;
3704
3705 return(errorcode);
3706 }
3707 else {
3708 return(0);
3709 }
3710 }
3711
3712
3713
3714 static struct DosList *attemptlockdoslist(LONG tries, LONG delay) {
3715 struct DosList *dol;
3716 struct DosPacket *dp;
3717
3718 for(;;) {
3719 dol=AttemptLockDosList(LDF_WRITE|LDF_VOLUMES);
3720
3721 if(((IPTR)dol & ~1)!=0) {
3722 return(dol);
3723 }
3724
3725 if(--tries<=0) {
3726 return(0);
3727 }
3728
3729 if((dp=getpacket(globals->mytask))!=0) {
3730 if(handlesimplepackets(dp)==0) {
3731 dumppackets(dp, ERROR_NOT_A_DOS_DISK);
3732 }
3733 }
3734 else {
3735 Delay(delay);
3736 }
3737 }
3738 }
3739
3740
3741 void removevolumenode(struct DosList *dol, struct DosList *vn) {
3742 while((dol=NextDosEntry(dol, LDF_VOLUMES))!=0) {
3743 if(dol==vn) {
3744 RemDosEntry(dol);
3745 break;
3746 }
3747 }
3748 }
3749
3750
3751 static void deinitdisk() {
3752
3753 /* This function flushes all caches, and then invalidates them.
3754 If successful, this function then proceeds to either remove
3755 the volumenode, or transfer any outstanding locks/notifies to
3756 it. Finally it notifies the system of the disk removal. */
3757
3758 _DEBUG(("deinitdisk: entry\n"));
3759
3760 flushcaches();
3761 invalidatecaches();
3762
3763 if(globals->volumenode!=0) {
3764
3765 /* We first check if the VolumeNode needs to be removed; if not
3766 then we do not lock the DosList and modify some of its fields.
3767 If it must be removed, we first attempt to lock the DosList
3768 synchronously; whether this fails or not, we always send a
3769 removal message to the DosList subtask. */
3770
3771 if(globals->locklist!=0 || globals->notifyrequests!=0) {
3772
3773 /* There are locks or notifyrequests, so we cannot kill the volumenode. */
3774
3775 /* We haven't got the DosList locked here, but I think it is fairly
3776 safe to modify these fields directly. */
3777
3778 Forbid();
3779
3780 globals->volumenode->dl_Task=0;
3781 globals->volumenode->dl_LockList=MKBADDR(globals->locklist);
3782 globals->volumenode->dl_unused=MKBADDR(globals->notifyrequests);
3783
3784 Permit();
3785
3786 globals->locklist=0;
3787 globals->notifyrequests=0;
3788 }
3789 else {
3790 struct SFSMessage *sfsm;
3791 struct DosList *dol=attemptlockdoslist(5, 1);
3792
3793 _DEBUG(("deinitdisk: dol = %ld\n", dol));
3794
3795 if(dol!=0) { /* Is DosList locked? */
3796 removevolumenode(dol, (struct DosList *)globals->volumenode);
3797 UnLockDosList(LDF_WRITE|LDF_VOLUMES);
3798 }
3799
3800 _DEBUG(("deinitdisk: sending msg\n"));
3801
3802 /* Even if we succesfully locked the DosList, we still should notify
3803 the DosList task to remove the node as well (and to free it), just
3804 in case a VolumeNode Add was still pending. */
3805
3806 if((sfsm=AllocVec(sizeof(struct SFSMessage), MEMF_CLEAR))!=0) {
3807 sfsm->command=SFSM_REMOVE_VOLUMENODE;
3808 sfsm->data=(IPTR)globals->volumenode;
3809 sfsm->msg.mn_Length=sizeof(struct SFSMessage);
3810
3811 PutMsg(globals->sdlhport, (struct Message *)sfsm);
3812 }
3813 }
3814
3815 _DEBUG(("deinitdisk: done\n"));
3816
3817 globals->volumenode=0;
3818
3819 diskchangenotify(IECLASS_DISKREMOVED);
3820 }
3821 }
3822
3823
3824
3825 LONG handlesimplepackets(struct DosPacket *packet) {
3826 LONG type=packet->dp_Type; /* After returnpacket, packet->dp_Type is invalid! */
3827
3828 switch(packet->dp_Type) {
3829 case ACTION_IS_FILESYSTEM:
3830 returnpacket2(packet, DOSTRUE,0);
3831 break;
3832 #ifndef __AROS__
3833 case ACTION_GET_DISK_FSSM:
3834 returnpacket2(packet, (LONG)startupmsg,0);
3835 break;
3836 case ACTION_FREE_DISK_FSSM:
3837 returnpacket2(packet, DOSTRUE,0);
3838 break;
3839 #endif
3840 case ACTION_DISK_INFO:
3841 actiondiskinfo(packet);
3842 break;
3843 case ACTION_SAME_LOCK:
3844 actionsamelock(packet);
3845 break;
3846 case ACTION_CURRENT_VOLUME:
3847 actioncurrentvolume(packet);
3848 break;
3849 default:
3850 return(0);
3851 }
3852
3853 return(type);
3854 }
3855
3856
3857
3858 static LONG dumppackets(struct DosPacket *packet,LONG returncode) {
3859 LONG type=packet->dp_Type; /* After returnpacket, packet->dp_Type is invalid! */
3860
3861 /* Routine which returns ERROR_NOT_A_DOS_DISK for all known
3862 packets which cannot be handled under such a situation */
3863
3864 switch(type) {
3865 case ACTION_READ:
3866 case ACTION_WRITE:
3867 case ACTION_SEEK:
3868 case ACTION_SET_FILE_SIZE:
3869 returnpacket2(packet, -1,returncode);
3870 break;
3871 case ACTION_CREATE_DIR:
3872 case ACTION_FINDUPDATE:
3873 case ACTION_FINDINPUT:
3874 case ACTION_FINDOUTPUT:
3875 case ACTION_END:
3876 case ACTION_EXAMINE_OBJECT:
3877 case ACTION_EXAMINE_NEXT:
3878 case ACTION_COPY_DIR:
3879 case ACTION_LOCATE_OBJECT:
3880 case ACTION_PARENT: /* till here verified to return 0 on error! */
3881 case ACTION_LOCK_RECORD:
3882 case ACTION_FREE_RECORD:
3883 case ACTION_FREE_LOCK:
3884 case ACTION_CHANGE_MODE:
3885 case ACTION_FH_FROM_LOCK:
3886 case ACTION_COPY_DIR_FH:
3887 case ACTION_PARENT_FH:
3888 case ACTION_EXAMINE_FH:
3889 case ACTION_EXAMINE_ALL:
3890 case ACTION_DELETE_OBJECT:
3891 case ACTION_RENAME_OBJECT:
3892 case ACTION_MAKE_LINK:
3893 case ACTION_READ_LINK:
3894 case ACTION_SET_COMMENT:
3895 case ACTION_SET_DATE:
3896 case ACTION_SET_PROTECT:
3897 case ACTION_INFO:
3898 case ACTION_RENAME_DISK:
3899 case ACTION_SERIALIZE_DISK:
3900 #ifndef __AROS__
3901 case ACTION_GET_DISK_FSSM:
3902 #endif
3903 case ACTION_MORE_CACHE:
3904 case ACTION_WRITE_PROTECT:
3905 case ACTION_ADD_NOTIFY:
3906 case ACTION_REMOVE_NOTIFY:
3907 case ACTION_INHIBIT: /* These packets are only dumped when doslist is locked */
3908 case ACTION_FORMAT:
3909 returnpacket2(packet, DOSFALSE,returncode);
3910 break;
3911 default:
3912 returnpacket2(packet, DOSFALSE,ERROR_ACTION_NOT_KNOWN);
3913 break;
3914 }
3915
3916 return(type);
3917 }
3918
3919
3920 #ifdef DEBUGCODE
3921 static void dumppacket() {
3922 struct DosPacket *packet;
3923
3924 /* routine which gets a packet and returns ERROR_NOT_A_DOS_DISK for all
3925 known packets which cannot be executed while we are attempting to access
3926 the doslist. Some packets which don't require disk access will be
3927 handled as normal. */
3928
3929 packet=waitpacket(globals->mytask);
3930
3931 if(handlesimplepackets(packet)==0) {
3932 dumppackets(packet,ERROR_NOT_A_DOS_DISK);
3933 }
3934 }
3935 #endif
3936
3937
3938 static void actioncurrentvolume(struct DosPacket *packet) {
3939 struct ExtFileLock *lock=(struct ExtFileLock *)packet->dp_Arg1;
3940
3941 _DEBUG(("ACTION_CURRENT_VOLUME(%ld)\n",lock));
3942
3943 if(lock==0) {
3944 _DEBUG(("ACTION_CURRENT_VOLUME: volumenode = %ld\n",globals->volumenode));
3945 returnpacket2(packet, (SIPTR)TOBADDR(globals->volumenode), 0);
3946 }
3947 else {
3948 returnpacket2(packet, (SIPTR)lock->volume,0);
3949 }
3950 }
3951
3952
3953
3954 static void actionsamelock(struct DosPacket *packet) {
3955 struct ExtFileLock *lock;
3956 struct ExtFileLock *lock2;
3957
3958 lock=(struct ExtFileLock *)BADDR(packet->dp_Arg1);
3959 lock2=(struct ExtFileLock *)BADDR(packet->dp_Arg2);
3960
3961 if(lock->objectnode==lock2->objectnode && lock->task==lock2->task) {
3962 returnpacket2(packet, DOSTRUE,0);
3963 return;
3964 }
3965 returnpacket2(packet, DOSFALSE,0);
3966 }
3967
3968
3969
3970 static void actiondiskinfo(struct DosPacket *packet) {
3971 struct InfoData *id=BADDR(packet->dp_Arg1);
3972
3973 _DEBUG(("ACTION_DISK_INFO\n"));
3974
3975 fillinfodata(id);
3976
3977 returnpacket2(packet, DOSTRUE,0);
3978 }
3979
3980
3981
3982 static void fillinfodata(struct InfoData *id) {
3983 ULONG usedblocks;
3984
3985 id->id_NumSoftErrors=globals->numsofterrors;
3986 id->id_UnitNumber=globals->startupmsg->fssm_Unit;
3987 id->id_DiskState=globals->diskstate;
3988 id->id_NumBlocks=globals->blocks_total-globals->blocks_reserved_start-globals->blocks_reserved_end;
3989
3990 usedblocks=id->id_NumBlocks;
3991
3992 if(globals->disktype == DOSTYPE_ID) {
3993 ULONG deletedfiles, deletedblocks;
3994
3995 getusedblocks(&usedblocks);
3996 if(getrecycledinfo(&deletedfiles, &deletedblocks)==0) {
3997 usedblocks-=deletedblocks;
3998 }
3999 }
4000
4001 id->id_NumBlocksUsed=usedblocks;
4002 id->id_BytesPerBlock=globals->bytes_block;
4003 id->id_DiskType=globals->disktype;
4004
4005 D(kprintf("Filling InfoData structure with a volumenode ptr to address %ld. Disktype = 0x%08lx\n", globals->volumenode, globals->disktype));
4006
4007 id->id_VolumeNode=TOBADDR(globals->volumenode);
4008
4009 _DEBUG(("fillinfodata: volumenode = %ld, disktype = 0x%08lx\n", globals->volumenode, globals->disktype));
4010
4011 if(globals->locklist!=0) {
4012 id->id_InUse=DOSTRUE;
4013 }
4014 else {
4015 id->id_InUse=DOSFALSE;
4016 }
4017 }
4018
4019
4020
4021 BOOL checkchecksum(struct CacheBuffer *cb) {
4022 #ifdef CHECKCHECKSUMSALWAYS
4023 if(CALCCHECKSUM(globals->bytes_block,cb->data)==0) {
4024 #else
4025 if((cb->bits & CB_CHECKSUM)!=0 || CALCCHECKSUM(globals->bytes_block,cb->data)==0) { // -> copycachebuffer screws this up!
4026 #endif
4027 cb->bits|=CB_CHECKSUM;
4028 return(DOSTRUE);
4029 }
4030 return(DOSFALSE);
4031 }
4032
4033
4034
4035 void setchecksum(struct CacheBuffer *cb) {
4036 struct fsBlockHeader *bh=cb->data;
4037
4038 bh->be_checksum=0; /* Important! */
4039 bh->be_checksum=L2BE(-CALCCHECKSUM(globals->bytes_block,cb->data));
4040 }
4041
4042
4043
4044 LONG readcachebuffercheck(struct CacheBuffer **returnedcb,ULONG blckno,ULONG type) {
4045 LONG errorcode;
4046 struct fsBlockHeader *bh;
4047
4048 while((errorcode=readcachebuffer(returnedcb,blckno))==0) {
4049 bh=(*returnedcb)->data;
4050 if(type!=0 && bh->id!=type) {
4051 dumpcachebuffers();
4052 outputcachebuffer(*returnedcb);
4053 emptycachebuffer(*returnedcb);
4054
4055 if(blckno!=0) {
4056 if(request(PROGRAMNAME " request","%s\n"\
4057 "has a blockid error in block %ld.\n"\
4058 "Expected was blockid 0x%08lx,\n"\
4059 "but the block says it is blockid 0x%08lx.",
4060 "Reread|Cancel",AROS_BSTR_ADDR(globals->devnode->dn_Name),blckno,type,bh->id)<=0) {
4061 return(INTERR_BLOCK_WRONG_TYPE);
4062 }
4063 }
4064 else {
4065 /* if(request(PROGRAMNAME " request","%s\n"\
4066 "is not a DOS disk.",
4067 "Retry|Cancel",AROS_BSTR_ADDR(devnode->dn_Name),blckno,type,bh->id)<=0) {
4068 return(INTERR_BLOCK_WRONG_TYPE);
4069 } */
4070
4071 return(INTERR_BLOCK_WRONG_TYPE);
4072 }
4073 continue;
4074 }
4075 if(checkchecksum(*returnedcb)==DOSFALSE) {
4076 dumpcachebuffers();
4077 outputcachebuffer(*returnedcb);
4078 emptycachebuffer(*returnedcb);
4079
4080 if(request(PROGRAMNAME " request","%s\n"\
4081 "has a checksum error in block %ld.",
4082 "Reread|Cancel",AROS_BSTR_ADDR(globals->devnode->dn_Name),blckno)<=0) {
4083 return(INTERR_CHECKSUM_FAILURE);
4084 }
4085 continue;
4086 }
4087 if(BE2L(bh->be_ownblock)!=blckno) {
4088 dumpcachebuffers();
4089 outputcachebuffer(*returnedcb);
4090 emptycachebuffer(*returnedcb);
4091
4092 if(request(PROGRAMNAME " request","%s\n"\
4093 "has a block error in block %ld.\n"\
4094 "Expected was block %ld,\n"\
4095 "but the block says it is block %ld.",
4096 "Reread|Cancel",AROS_BSTR_ADDR(globals->devnode->dn_Name),blckno,blckno,BE2L(bh->be_ownblock))<=0) {
4097 return(INTERR_OWNBLOCK_WRONG);
4098 }
4099 continue;
4100 }
4101 break;
4102 }
4103 return(errorcode);
4104 }
4105
4106
4107
4108 /* How the CacheBuffers work:
4109 ==========================
4110
4111 When the filesystem starts, the number of buffers indicated
4112 by the Mountlist are allocated. If the number of buffers
4113 is below the minimum then the filesystem will increase the
4114 number of buffers to the minimum. AddBuffers can be used
4115 later to change the number of CacheBuffers.
4116
4117 Each CacheBuffer is linked into two chains. An LRU chain,
4118 to quickly determine the least recently used CacheBuffer,
4119 and a Hash chain. The Hash chain is used to quickly locate
4120 a CacheBuffer which contains a specific block. Empty
4121 cachebuffers are not linked in the Hash chain and have a
4122 blckno of zero.
4123
4124 After having read a few blocks there comes a time when you
4125 want to modify them. The CacheBuffer systems helps to make
4126 it simple to do safe updates to blocks without ever running
4127 the risk of leaving the disk in a state where links or
4128 pointers are not yet valid. If you want to modify a block
4129 or series of blocks you need to tell this to the caching
4130 system by calling newtransaction(). An operation is a series
4131 of modifications which, when written to disk completely,
4132 would result in a valid disk. By calling newtransaction() you
4133 signal that you are about to start a series of modifications
4134 which together will again result in a valid disk.
4135
4136 If however at any point during an operation somekind of
4137 error occurs which prevents you from finishing the operation
4138 you should call deletetransaction(). This will remove all
4139 changes you made from the point when you called
4140 newtransaction() from the cache. These blocks will now never
4141 get written to disk, so there is no chance that the disk
4142 becomes invalid by partial modifications.
4143
4144 This sums up how the caching mechanism works. The internal
4145 workings of routines like newtransaction() and
4146 deletetransaction() will be explained later on. One very
4147 important routine hasn't been mentioned here:
4148 flushtransaction(). This is the routine which actually makes
4149 modifications to the disk. It does this by flushing one
4150 operation at a time to disk (in old to new order of course)
4151 in such a way that even if the machine crashed in the middle
4152 of the flush that the disk would remain valid. After
4153 flushing all operations the cache is cleaned up.
4154
4155 */
4156
4157
4158
4159
4160 /* Creating and moving objects
4161
4162 1. Changing the comment on an object
4163 2. Changing the name of an object
4164 3. Creating a new object
4165 (4. Moving an object)
4166
4167 Each of these three operations involves one or more of the following:
4168
4169 1,2,3,4 - Locating enough new room for the object
4170 1,2,3,4 - Making sure the object-node points to the new block the
4171 object is located in.
4172 2 & 3 - Hashing the object
4173 3 - Allocating an ObjectNode.
4174
4175 Order:
4176
4177 'Allocating an ObjectNode' always precedes 'Hashing the Object' and 'Fixing the objectnode pointer'.
4178 'FindObjectSpace' always precedes 'Fixing the objectnode pointer'.
4179
4180 1. FindObjectSpace OR Allocating an ObjectNode
4181 2. Fixing the objectnode pointer OR Hashing the Object */
4182
4183
4184
4185 void fixlocks(struct GlobalHandle *gh,ULONG lastextentkey,ULONG lastextentoffset,ULONG filelength) {
4186 struct ExtFileLock *lock=globals->locklist;
4187
4188 while(lock!=0) {
4189 if(lock->gh==gh) {
4190 if(filelength==0) {
4191 lock->offset=0;
4192 lock->extentoffset=0;
4193 lock->curextent=0;
4194 }
4195 else if(lock->offset>filelength) {
4196 /* Hmmm, this lock is positioned beyond the EOF... */
4197
4198 if(lock->offset-lock->extentoffset >= filelength) {
4199 lock->extentoffset=filelength-(lock->offset-lock->extentoffset);
4200 }
4201 else {
4202 lock->extentoffset=filelength-lastextentoffset;
4203 lock->curextent=lastextentkey;
4204 }
4205 lock->offset=filelength;
4206 }
4207 }
4208 lock=lock->next;
4209 }
4210 }
4211
4212
4213
4214 static LONG extendblocksinfile(struct ExtFileLock *lock, ULONG blocks) {
4215 BLCK lastextentbnode;
4216 LONG errorcode;
4217
4218 /* This function extends the file identified by the lock with a number
4219 of blocks. Only new Extents will be created -- the size of the file
4220 will not be altered, and changing it is left up to the caller. If
4221 the file did not have any blocks yet, then lock->curextent will be
4222 set to the first (new) ExtentBNode. It's left up up to the caller
4223 to reflect this change in object.file.data.
4224
4225 This function must be called from within a transaction. */
4226
4227 _XDEBUG((DEBUG_IO,"extendblocksinfile: Increasing number of blocks by %ld. lock->curextent = %ld\n",blocks,lock->curextent));
4228
4229 if((errorcode=seektocurrent(lock))==0) {
4230
4231 if((lastextentbnode=lock->curextent)!=0) {
4232 struct CacheBuffer *cb;
4233 struct fsExtentBNode *ebn;
4234
4235 while((errorcode=findextentbnode(lastextentbnode,&cb,&ebn))==0 && BE2L(ebn->be_next)!=0) {
4236 lastextentbnode=BE2L(ebn->be_next);
4237 }
4238 }
4239
4240 if(errorcode==0) {
4241 struct GlobalHandle *gh=lock->gh;
4242
4243 /* We found the last Extent. Now we should see if we can extend it
4244 or if we need to add a new one and attach it to this one. */
4245
4246 while(blocks!=0) {
4247 struct Space *sl=globals->spacelist;
4248 BLCK searchstart;
4249
4250 if(lastextentbnode!=0) {
4251 struct CacheBuffer *cb;
4252 struct fsExtentBNode *ebn;
4253
4254 if((errorcode=findextentbnode(lastextentbnode,&cb,&ebn))!=0) {
4255 break;
4256 }
4257 searchstart=BE2L(ebn->be_key)+BE2W(ebn->be_blocks);
4258 }
4259 else {
4260 searchstart=globals->block_rovingblockptr;
4261 }
4262
4263 if((errorcode=smartfindandmarkspace(searchstart,blocks))!=0) { /* only within transaction! */
4264 _DEBUG(("extendblocksinfile: sfams returned errorcode %ld\n", errorcode));
4265 break;
4266 }
4267
4268 _XDEBUG((DEBUG_IO,"extendblocksinfile: Found some space! blocks = %ld\n",blocks));
4269
4270 while(blocks!=0 && sl->block!=0) {
4271 BLCK newspace=sl->block;
4272 ULONG newspaceblocks;
4273
4274 newspaceblocks=sl->blocks > blocks ? blocks : sl->blocks;
4275
4276 while(newspaceblocks!=0) {
4277 ULONG extentblocks;
4278
4279 extentblocks=newspaceblocks > 8192 ? 8192 : newspaceblocks;
4280
4281 newspaceblocks-=extentblocks;
4282
4283 _XDEBUG((DEBUG_IO,"extendblocksinfile: sl->block = %ld, lastextentbnode = %ld, extentblocks = %ld\n",sl->block,lastextentbnode,extentblocks));
4284
4285 if((errorcode=addblocks(extentblocks, newspace, gh->objectnode, &lastextentbnode))!=0) {
4286 _DEBUG(("extendblocksinfile: addblocks returned errorcode %ld\n", errorcode));
4287 return(errorcode);
4288 }
4289
4290 if(lock->curextent==0) {
4291 lock->curextent=lastextentbnode;
4292 }
4293
4294 lock->lastextendedblock=newspace + extentblocks;
4295
4296 _XDEBUG((DEBUG_IO,"extendblocksinfile: Done adding or extending an extent -- blocks = %ld, extentblocks = %ld\n",blocks,extentblocks));
4297
4298 blocks-=extentblocks;
4299 newspace+=extentblocks;
4300 }
4301 sl++;
4302 }
4303 }
4304 }
4305 }
4306
4307 return(errorcode);
4308 }
4309
4310
4311
4312 LONG truncateblocksinfile(struct ExtFileLock *lock,ULONG blocks,ULONG *lastextentkey,ULONG *lastextentoffset) {
4313 struct CacheBuffer *cb;
4314 struct fsExtentBNode *ebn;
4315 ULONG offset;
4316 ULONG extentoffset;
4317 LONG errorcode;
4318
4319 /* Truncates the specified file to /blocks/ blocks. This function does not
4320 take care of setting the filesize. It also doesn't check for any locks
4321 which have a fileptr which is beyond the end of the file after calling
4322 this function. Its sole purpose is to reduce the number of blocks in
4323 the Extent list. */
4324
4325 offset=blocks<<globals->shifts_block;
4326
4327 _DEBUG(("truncateblocksinfile: truncating file by %ld blocks\n",blocks));
4328
4329 if((errorcode=seekextent(lock,offset,&cb,&ebn,&extentoffset))==0) {
4330
4331 _DEBUG(("truncateblocksinfile: offset = %ld, extentoffset = %ld\n",offset,extentoffset));
4332
4333 if(offset-extentoffset==0) {
4334 ULONG prevkey=BE2L(ebn->be_prev);
4335
4336 _DEBUG(("truncateblocksinfile: prevkey = %ld\n",prevkey));
4337
4338 /* Darn. This Extent needs to be killed completely, meaning that we
4339 have to set the Next pointer of the previous Extent to zero. */
4340
4341 deleteextents(BE2L(ebn->be_key));
4342
4343 if((prevkey & 0x80000000)==0) {
4344 if((errorcode=findextentbnode(prevkey,&cb,&ebn))==0) {
4345 preparecachebuffer(cb);
4346
4347 ebn->be_next=0;
4348
4349 errorcode=storecachebuffer(cb);
4350
4351 *lastextentkey=prevkey;
4352 *lastextentoffset=extentoffset-(BE2W(ebn->be_blocks)<<globals->shifts_block);
4353 }
4354 }
4355 else {
4356 struct fsObject *o;
4357
4358 if((errorcode=readobject((prevkey & 0x7fffffff), &cb, &o))==0) {
4359 preparecachebuffer(cb);
4360
4361 _DEBUG(("truncateblocksinfile: cb->blckno = %ld\n",cb->blckno));
4362
4363 o->object.file.be_data=0;
4364 lock->gh->data=0;
4365
4366 errorcode=storecachebuffer(cb);
4367
4368 *lastextentkey=0;
4369 *lastextentoffset=0;
4370 }
4371 }
4372 }
4373 else {
4374 ULONG newblocks=blocks-(extentoffset>>globals->shifts_block);
4375
4376 *lastextentkey=BE2L(ebn->be_key);
4377 *lastextentoffset=extentoffset;
4378
4379 _DEBUG(("truncateblocksinfile: newblocks = %ld, ebn->blocks = %ld\n",newblocks,BE2W(ebn->be_blocks)));
4380
4381 if(newblocks!=BE2W(ebn->be_blocks)) {
4382 /* There is only one case where newblocks could equal en->blocks here,
4383 and that is if we tried to truncate the file to the same number of
4384 blocks the file already had! */
4385
4386 lockcachebuffer(cb);
4387
4388 if((errorcode=freespace(BE2L(ebn->be_key)+newblocks,BE2W(ebn->be_blocks)-newblocks))==0) {
4389 BLCK next=BE2L(ebn->be_next);
4390
4391 preparecachebuffer(cb);
4392
4393 ebn->be_blocks=W2BE(newblocks);
4394 ebn->be_next=0;
4395
4396 if((errorcode=storecachebuffer(cb))==0) {
4397 errorcode=deleteextents(next); // Careful, deleting BNode's may change the location of other BNode's as well!
4398 }
4399 }
4400
4401 unlockcachebuffer(cb);
4402 }
4403 }
4404 }
4405
4406 return(errorcode);
4407 }
4408
4409
4410
4411 LONG setfilesize(struct ExtFileLock *lock, ULONG bytes) {
4412 struct GlobalHandle *gh=lock->gh;
4413 LONG errorcode=0;
4414
4415 /* This function sets the filesize of a file to /bytes/ bytes. If the
4416 file is not yet long enough, additional blocks are allocated and
4417 added to the file. If the file is too long the file will be shortened
4418 and the lost blocks are freed.
4419
4420 Any filehandles using this file are set to the EOF if their current
4421 position would be beyond the new EOF when truncating the file.
4422
4423 In any other case the position of the file ptr is not altered. */
4424
4425 _DEBUG(("setfilesize: gh = 0x%08lx. Setting to %ld bytes. Current size is %ld bytes.\n",gh,bytes,gh->size));
4426
4427 if(bytes!=gh->size) {
4428 LONG blocksdiff;
4429 LONG curblocks;
4430
4431 curblocks=(gh->size+globals->bytes_block-1)>>globals->shifts_block;
4432 blocksdiff=((bytes+globals->bytes_block-1)>>globals->shifts_block) - curblocks;
4433
4434 _DEBUG(("setfilesize: blocksdiff = %ld\n",blocksdiff));
4435
4436 if(blocksdiff>0) {
4437
4438 newtransaction();
4439
4440 if((errorcode=extendblocksinfile(lock, blocksdiff))==0) {
4441 struct CacheBuffer *cb;
4442 struct fsObject *o;
4443
4444 /* File (now) has right amount of blocks, only exact size in bytes may differ */
4445
4446 if((errorcode=readobject(gh->objectnode, &cb, &o))==0) {
4447 preparecachebuffer(cb);
4448
4449 o->object.file.be_size=L2BE(bytes);
4450 if(o->object.file.be_data==0) {
4451 o->object.file.be_data=L2BE(lock->curextent);
4452 }
4453
4454 errorcode=storecachebuffer(cb);
4455 }
4456 }
4457
4458 if(errorcode==0) {
4459 endtransaction();
4460 gh->size=bytes;
4461 if(gh->data==0) {
4462 gh->data=lock->curextent;
4463 }
4464 }
4465 else {
4466 deletetransaction();
4467 }
4468 }
4469 else {
4470 ULONG lastextentkey=0;
4471 ULONG lastextentoffset=0;
4472
4473 newtransaction();
4474
4475 if(blocksdiff<0) {
4476 /* File needs to be shortened by -/blocksdiff/ blocks. */
4477
4478 _DEBUG(("setfilesize: Decreasing number of blocks\n"));
4479
4480 errorcode=truncateblocksinfile(lock,curblocks+blocksdiff,&lastextentkey,&lastextentoffset);
4481 }
4482
4483 _DEBUG(("setfilesize: lastextentkey = %ld, lastextentoffset = %ld\n",lastextentkey,lastextentoffset));
4484
4485 if(errorcode==0) {
4486 struct CacheBuffer *cb;
4487 struct fsObject *o;
4488
4489 /* File (now) has right amount of blocks, only exact size in bytes may differ */
4490
4491 if((errorcode=readobject(gh->objectnode,&cb,&o))==0) {
4492 preparecachebuffer(cb);
4493
4494 _DEBUG(("setfilesize: gh->objectnode = %ld, cb->blcno = %ld\n",gh->objectnode,cb->blckno));
4495
4496 o->object.file.be_size=L2BE(bytes);
4497
4498 errorcode=storecachebuffer(cb);
4499 }
4500 }
4501
4502 if(errorcode==0) {
4503 endtransaction();
4504 gh->size=bytes;
4505
4506 fixlocks(gh,lastextentkey,lastextentoffset,bytes);
4507 }
4508 else {
4509 deletetransaction();
4510 }
4511 }
4512
4513 if(errorcode==0) {
4514 lock->bits|=EFL_MODIFIED;
4515 }
4516 }
4517
4518 return(errorcode);
4519 }
4520
4521
4522
4523 void seekforward(struct ExtFileLock *lock, UWORD ebn_blocks, BLCK ebn_next, ULONG bytestoseek) {
4524
4525 /* This function does a simple forward seek. It assumes /bytestoseek/ is
4526 only large enough to skip within the current extent or to the very
4527 beginning of the next extent. */
4528
4529 lock->offset+=bytestoseek;
4530 lock->extentoffset+=bytestoseek;
4531 if(lock->extentoffset >= ebn_blocks<<globals->shifts_block && ebn_next!=0) {
4532 lock->extentoffset=0;
4533 lock->curextent=ebn_next;
4534 }
4535 }
4536
4537
4538
4539 LONG seektocurrent(struct ExtFileLock *lock) {
4540 LONG errorcode=0;
4541
4542 /* This function checks if the currentextent is still valid. If not,
4543 it will attempt to locate the currentextent. */
4544
4545 if(lock->curextent==0) {
4546
4547 /* lock->curextent==0 can indicate 2 things:
4548
4549 - A previously empty file was extended by another handle; in this
4550 case the file-ptr (lock->offset) of this handle is still zero.
4551
4552 - The extent has been moved by the defragmenter, and will have to
4553 be re-located. In this case the file-ptr doesn't have to be
4554 zero. */
4555
4556 if(lock->offset==0) {
4557 lock->curextent=lock->gh->data;
4558 }
4559 else {
4560 struct CacheBuffer *cb;
4561 struct fsExtentBNode *ebn;
4562 ULONG extentoffset;
4563
4564 if((errorcode=seekextent(lock, lock->offset, &cb, &ebn, &extentoffset))==0) {
4565 lock->curextent=BE2L(ebn->be_key);
4566 lock->extentoffset=lock->offset - extentoffset;
4567 }
4568 }
4569 }
4570
4571 return(errorcode);
4572 }
4573
4574
4575 static LONG seek(struct ExtFileLock *lock,ULONG offset) {
4576 struct CacheBuffer *cb;
4577 struct fsExtentBNode *ebn;
4578 ULONG extentoffset;
4579 LONG errorcode;
4580
4581 /* This function moves the file-ptr to the specified absolute file
4582 position. It will return an error if you try to seek beyond the
4583 end of the file. */
4584
4585 _XDEBUG((DEBUG_SEEK,"seek: Attempting to seek to %ld\n",offset));
4586
4587 if((errorcode=seekextent(lock,offset,&cb,&ebn,&extentoffset))==0) {
4588 lock->curextent=BE2L(ebn->be_key);
4589 lock->extentoffset=offset-extentoffset;
4590 lock->offset=offset;
4591
4592 _XDEBUG((DEBUG_SEEK,"seek: lock->curextent = %ld, lock->extentoffset = %ld, lock->offset = %ld\n",lock->curextent,lock->extentoffset,lock->offset));
4593 }
4594
4595 _XDEBUG((DEBUG_SEEK,"seek: Exiting with errorcode %ld\n",errorcode));
4596
4597 return(errorcode);
4598 }
4599
4600
4601
4602 LONG deleteextents(ULONG key) {
4603 struct CacheBuffer *cb;
4604 struct fsExtentBNode *ebn;
4605 LONG errorcode=0;
4606
4607 /* Deletes an fsExtentBNode structure by key and any fsExtentBNodes linked to it.
4608 This function DOES NOT fix the next pointer in a possible fsExtentBNode which
4609 might have been pointing to the first BNode we are deleting. Make sure you check
4610 this yourself, if needed.
4611
4612 If key is zero, than this function does nothing.
4613
4614 newtransaction() should have been called prior to calling this function. */
4615
4616 _XDEBUG((DEBUG_NODES,"deleteextents: Entry -- deleting extents from key %ld\n",key));
4617
4618
4619 while(key!=0 && (errorcode=findbnode(globals->block_extentbnoderoot,key,&cb,(struct BNode **)&ebn))==0) {
4620 /* node to be deleted located. */
4621
4622 // _XDEBUG((DDEBUG_NODES,"deleteextents: Now deleting key %ld. Next key is %ld\n",key,ebn->next));
4623
4624 key=BE2L(ebn->be_next);
4625
4626 lockcachebuffer(cb); /* Makes sure freespace() doesn't reuse this cachebuffer */
4627
4628 if((errorcode=freespace(BE2L(ebn->be_key), BE2W(ebn->be_blocks)))==0) {
4629 unlockcachebuffer(cb);
4630
4631 // _XDEBUG((DDEBUG_NODES,"deleteextents: deletebnode from root %ld, with key %ld\n",block_extentbnoderoot,ebn->key));
4632
4633 if((errorcode=deletebnode(globals->block_extentbnoderoot,BE2L(ebn->be_key)))!=0) { /*** Maybe use deleteinternalnode here??? */
4634 break;
4635 }
4636 }
4637 else {
4638 unlockcachebuffer(cb);
4639 break;
4640 }
4641 }
4642
4643 // _XDEBUG((DEBUG_NODES,"deleteextents: Exiting with errorcode %ld\n",errorcode));
4644
4645 return(errorcode);
4646 }
4647
4648
4649
4650 static LONG findextentbnode(ULONG key,struct CacheBuffer **returned_cb,struct fsExtentBNode **returned_bnode) {
4651 LONG errorcode;
4652
4653 errorcode=findbnode(globals->block_extentbnoderoot,key,returned_cb,(struct BNode **)returned_bnode);
4654
4655 #ifdef CHECKCODE_BNODES
4656 if(*returned_bnode==0 || BE2L((*returned_bnode)->be_key)!=key) {
4657 dreq("findextentbnode: findbnode() can't find key %ld!",key);
4658 outputcachebuffer(*returned_cb);
4659 return(INTERR_BTREE);
4660 }
4661 #endif
4662
4663 return(errorcode);
4664 }
4665
4666
4667 /*
4668 LONG findobjectnode(NODE nodeno,struct CacheBuffer **returned_cb,struct fsObjectNode **returned_node) {
4669 return(findnode(block_objectnoderoot, sizeof(struct fsObjectNode), nodeno, returned_cb, (struct fsNode **)returned_node));
4670 }
4671 */
4672
4673
4674 static inline LONG createextentbnode(ULONG key,struct CacheBuffer **returned_cb,struct fsExtentBNode **returned_bnode) {
4675 return(createbnode(globals->block_extentbnoderoot,key,returned_cb,(struct BNode **)returned_bnode));
4676 }
4677
4678
4679
4680 LONG seekextent(struct ExtFileLock *lock, ULONG offset, struct CacheBuffer **returned_cb, struct fsExtentBNode **returned_ebn, ULONG *returned_extentoffset) {
4681 BLCK extentbnode;
4682 LONG errorcode=0;
4683
4684 /* When seeking there are 2 options; we start from the current extent,
4685 or we start from the first extent. Below we determine the best
4686 startpoint: */
4687
4688 if(offset>lock->gh->size) {
4689 _XDEBUG((DEBUG_SEEK,"seekextent: Attempting to seek beyond file\n"));
4690
4691 return(ERROR_SEEK_ERROR);
4692 }
4693
4694 // _DEBUG(("seekextent: offset = %ld, lock->offset = %ld, lock->extentoffset = %ld, lock->curextent = %ld\n",offset, lock->offset, lock->extentoffset, lock->curextent));
4695
4696 if(lock->curextent!=0 && offset >= lock->offset - lock->extentoffset) {
4697 extentbnode=lock->curextent;
4698 *returned_extentoffset=lock->offset - lock->extentoffset;
4699 }
4700 else {
4701 extentbnode=lock->gh->data;
4702 *returned_extentoffset=0;
4703 }
4704
4705 /* Starting point has been determined. Let the seeking begin!
4706 We keep getting the next extent, until we find the extent which
4707 contains the required offset. */
4708
4709 if(extentbnode!=0) {
4710 while((errorcode=findextentbnode(extentbnode,returned_cb,returned_ebn))==0) {
4711 ULONG endbyte=*returned_extentoffset+(BE2W((*returned_ebn)->be_blocks)<<globals->shifts_block);
4712
4713 if(offset>=*returned_extentoffset && offset<endbyte) {
4714 /* Hooray! We found the correct extent. */
4715 break;
4716 }
4717
4718 if(BE2L((*returned_ebn)->be_next)==0) {
4719 /* This break is here in case we run into the end of the file.
4720 This prevents *returned_extentoffset and extentbnode
4721 from being destroyed in the lines below, since it is still
4722 valid to seek to the EOF */
4723
4724 if(offset>endbyte) {
4725 /* There where no more blocks, but there should have been... */
4726 errorcode=ERROR_SEEK_ERROR;
4727 }
4728 break;
4729 }
4730
4731 *returned_extentoffset+=BE2W((*returned_ebn)->be_blocks)<<globals->shifts_block;
4732 extentbnode=BE2L((*returned_ebn)->be_next);
4733 }
4734 }
4735
4736 return(errorcode);
4737 }
4738
4739
4740
4741 /* Notify support functions. */
4742
4743 UBYTE *fullpath(struct CacheBuffer *cbstart,struct fsObject *o) {
4744 struct fsObjectContainer *oc=cbstart->data;
4745 struct CacheBuffer *cb=cbstart;
4746 UBYTE *path=&globals->pathstring[519];
4747 UBYTE *name;
4748
4749 /* Returns the full path of an object, or 0 if it fails. */
4750
4751 lockcachebuffer(cbstart);
4752
4753 *path=0;
4754
4755 while(oc->be_parent!=0) { /* Checking parent here means name in ROOT will be ignored. */
4756 name=o->name;
4757 while(*++name!=0) {
4758 }
4759
4760 while(name!=o->name) {
4761 *--path=upperchar(*--name);
4762 }
4763
4764 if(readobject(BE2L(oc->be_parent),&cb,&o)!=0) {
4765 path=0;
4766 break;
4767 }
4768
4769 oc=cb->data;
4770
4771 if(oc->be_parent!=0) {
4772 *--path='/';
4773 }
4774 }
4775
4776 unlockcachebuffer(cbstart);
4777
4778 return(path);
4779 }
4780
4781
4782
4783 void checknotifyforpath(UBYTE *path,UBYTE notifyparent) {
4784 struct NotifyRequest *nr;
4785 UBYTE *s1,*s2;
4786 UBYTE *lastslash;
4787
4788 /* /path/ doesn't have a trailing slash and start with a root directory (no colon) */
4789
4790 s1=path;
4791 lastslash=path-1;
4792 while(*s1!=0) {
4793 if(*s1=='/') {
4794 lastslash=s1;
4795 }
4796 s1++;
4797 }
4798
4799 nr=globals->notifyrequests;
4800
4801 // _DEBUG(("checknotify: path = '%s'\n", path));
4802
4803 while(nr!=0) {
4804
4805 s1=path;
4806 s2=stripcolon(nr->nr_FullName);
4807
4808 while(*s1!=0 && *s2!=0 && *s1==upperchar(*s2)) {
4809 s1++; // If last character doesn't match, this increment won't take place.
4810 s2++;
4811 }
4812
4813 /* "" == "hallo" -> no match
4814 "" == "/" -> match
4815 "" == "" -> match
4816 "/shit" == "" -> match (parent dir)
4817 "shit" == "" -> match (parent dir) */
4818
4819 // _DEBUG(("checknotify: fullpath = '%s', nr->FullName = '%s'\n",s1,s2));
4820
4821 if( (s1[0]==0 && (s2[0]==0 || (s2[0]=='/' && s2[1]==0))) || ((s2[0]==0 && (s1==lastslash || s1==lastslash+1)) && notifyparent==TRUE) ) {
4822 /* Wow, the string in the NotifyRequest matches! We need to notify someone! */
4823
4824 _DEBUG(("checknotify: Notificating!! nr->FullName = %s, UserData = 0x%08lx\n",nr->nr_FullName, nr->nr_UserData));
4825
4826 notify(nr);
4827
4828 /* No else, if neither flag is set then do nothing. */
4829 }
4830
4831 nr = (struct NotifyRequest *)nr->nr_Next;
4832 }
4833 }
4834
4835
4836
4837 void checknotifyforobject(struct CacheBuffer *cb,struct fsObject *o,UBYTE notifyparent) {
4838 checknotifyforpath(fullpath(cb,o),notifyparent);
4839 }
4840
4841
4842
4843 void notify(struct NotifyRequest *nr) {
4844
4845 /* This function sends a Notify to the client indicated by the passed
4846 in notifyrequest structure. */
4847
4848 if((nr->nr_Flags & NRF_SEND_SIGNAL)!=0) {
4849 /* Sending them a signal. */
4850
4851 _DEBUG(("notify: Sending signal\n"));
4852
4853 Signal(nr->nr_stuff.nr_Signal.nr_Task,1<<nr->nr_stuff.nr_Signal.nr_SignalNum);
4854 }
4855 else if((nr->nr_Flags & NRF_SEND_MESSAGE)!=0) {
4856 struct NotifyMessage *nm;
4857
4858 /* Sending them a message. */
4859
4860 _DEBUG(("notify: Sending message\n"));
4861
4862 if((nm=AllocMem(sizeof(struct NotifyMessage),MEMF_CLEAR))!=0) {
4863 nm->nm_ExecMessage.mn_ReplyPort=globals->msgportnotify;
4864 nm->nm_ExecMessage.mn_Length=sizeof(struct NotifyMessage);
4865
4866 nm->nm_Class=NOTIFY_CLASS;
4867 nm->nm_Code=NOTIFY_CODE;
4868 nm->nm_NReq=(struct NotifyRequest *)nr;
4869
4870 _DEBUG(("notify: PutMsg() - UserData = 0x%08lx\n", nr->nr_UserData));
4871
4872 PutMsg(nr->nr_stuff.nr_Msg.nr_Port,(struct Message *)nm);
4873 }
4874 }
4875 }
4876
4877
4878
4879
4880
4881
4882 #if 0
4883 LONG writedata(ULONG newbytes, ULONG extentblocks, BLCK newspace, UBYTE *data) {
4884 ULONG blocks=newbytes>>shifts_block;
4885 LONG errorcode=0;
4886
4887 if(blocks>extentblocks) {
4888 blocks=extentblocks;
4889 }
4890
4891 if(blocks!=0 && (errorcode=write(newspace,data,blocks))!=0) {
4892 return(errorcode);
4893 }
4894
4895 if(blocks<extentblocks) {
4896 struct CacheBuffer *cb;
4897
4898 _XDEBUG((DEBUG_IO," writedata: blocks = %ld, newbytes = %ld\n",blocks,newbytes));
4899
4900 newbytes-=blocks<<shifts_block;
4901 data+=blocks<<shifts_block;
4902
4903 if((cb=newcachebuffer(newspace+blocks))!=0) {
4904 unlockcachebuffer(cb);
4905
4906 CopyMem(data,cb->data,newbytes);
4907
4908 errorcode=writecachebuffer(cb);
4909 /* At this point we can do 2 things with this cachebuffer. We can leave it
4910 hashed so if the user requests part of this block again it can quickly be grabbed
4911 from this CacheBuffer. The other option is the call emptycachebuffer()
4912 and let this buffer be reused ASAP. */
4913
4914 emptycachebuffer(cb);
4915 }
4916 else {
4917 errorcode=ERROR_NO_FREE_STORE;
4918 }
4919 }
4920
4921 return(errorcode);
4922 }
4923 #endif
4924
4925
4926
4927
4928
4929
4930
4931
4932 static LONG addblocks(UWORD blocks, BLCK newspace, NODE objectnode, BLCK *io_lastextentbnode) {
4933 struct CacheBuffer *cb;
4934 struct fsExtentBNode *ebn;
4935 LONG errorcode;
4936
4937 /* This function adds /blocks/ blocks starting at block /newspace/ to a file
4938 identified by /objectnode/ and /lastextentbnode/. /io_lastextentbnode/ can
4939 be zero if there is no ExtentBNode chain attached to this file yet.
4940
4941 This function must be called from within a transaction.
4942
4943 /blocks/ ranges from 1 to 8192. To be able to extend Extents which are
4944 almost full, it is wise to make this value no higher than 8192 blocks.
4945
4946 /io_lastextentbnode/ will contain the new lastextentbnode value when this
4947 function completes.
4948
4949 This function makes no attempt to update any locks associated with this file,
4950 nor does it update the filesize information in a possible globalhandle.
4951
4952 If there was no chain yet, then this function will create a new one. However
4953 it will NOT update object.file.data -- this is left up to the caller. */
4954
4955 if(*io_lastextentbnode!=0) {
4956 /* There was already a ExtentBNode chain for this file. Extending it. */
4957
4958 _XDEBUG((DEBUG_IO," addblocks: Extending existing ExtentBNode chain.\n"));
4959
4960 if((errorcode=findextentbnode(*io_lastextentbnode,&cb,&ebn))==0) {
4961
4962 preparecachebuffer(cb);
4963
4964 if(BE2L(ebn->be_key)+BE2W(ebn->be_blocks)==newspace && BE2W(ebn->be_blocks)+blocks<65536) {
4965 /* It is possible to extent the last ExtentBNode! */
4966
4967 _XDEBUG((DEBUG_IO," addblocks: Extending last ExtentBNode.\n"));
4968
4969 ebn->be_blocks=W2BE(BE2W(ebn->be_blocks)+blocks);
4970
4971 errorcode=storecachebuffer(cb);
4972 }
4973 else {
4974 /* It isn't possible to extent the last ExtentBNode so we create
4975 a new one and link it to the last ExtentBNode. */
4976
4977 ebn->be_next=L2BE(newspace);
4978
4979 if((errorcode=storecachebuffer(cb))==0 && (errorcode=createextentbnode(newspace,&cb,&ebn))==0) {
4980
4981 _XDEBUG((DEBUG_IO," addblocks: Created new ExtentBNode.\n"));
4982
4983 ebn->be_key=L2BE(newspace);
4984 ebn->be_prev=L2BE(*io_lastextentbnode);
4985 ebn->be_next=0;
4986 ebn->be_blocks=W2BE(blocks);
4987
4988 *io_lastextentbnode=newspace;
4989
4990 if((errorcode=storecachebuffer(cb))==0) {
4991 globals->block_rovingblockptr=newspace+blocks;
4992 if((blocks<<globals->shifts_block) <= ROVING_SMALL_WRITE) {
4993 globals->block_rovingblockptr+=ROVING_RESERVED_SPACE>>globals->shifts_block;
4994 }
4995
4996 if(globals->block_rovingblockptr>=globals->blocks_total) {
4997 globals->block_rovingblockptr=0;
4998 }
4999 }
5000 }
5001 }
5002 }
5003 }
5004 else {
5005 /* There is no ExtentBNode chain yet for this file. Attaching one! */
5006
5007 if((errorcode=createextentbnode(newspace,&cb,&ebn))==0) {
5008
5009 _XDEBUG((DEBUG_IO," addblocks: Created new ExtentBNode chain.\n"));
5010
5011 ebn->be_key=L2BE(newspace);
5012 ebn->be_prev=L2BE(objectnode+0x80000000);
5013 ebn->be_next=0;
5014 ebn->be_blocks=W2BE(blocks);
5015
5016 *io_lastextentbnode=newspace;
5017
5018 if((errorcode=storecachebuffer(cb))==0) {
5019 globals->block_rovingblockptr=newspace+blocks;
5020 if((blocks<<globals->shifts_block) <= ROVING_SMALL_WRITE) {
5021 globals->block_rovingblockptr+=ROVING_RESERVED_SPACE>>globals->shifts_block;
5022 }
5023
5024 if(globals->block_rovingblockptr>=globals->blocks_total) {
5025 globals->block_rovingblockptr=0;
5026 }
5027 }
5028 }
5029 }
5030
5031 return(errorcode);
5032 }
5033
5034
5035
5036 static void diskchangenotify(ULONG class) {
5037 struct IOStdReq *inputreq;
5038 struct MsgPort *inputport;
5039 struct InputEvent ie;
5040 struct timeval tv;
5041
5042 if((inputport=CreateMsgPort())!=0) {
5043 if((inputreq=(struct IOStdReq *)CreateIORequest(inputport,sizeof(struct IOStdReq)))!=0) {
5044 if(OpenDevice("input.device",0,(struct IORequest *)inputreq,0)==0) {
5045
5046 GetSysTime(&tv);
5047
5048 ie.ie_NextEvent=0;
5049 ie.ie_Class=class;
5050 ie.ie_SubClass=0;
5051 ie.ie_Code=0;
5052 ie.ie_Qualifier=IEQUALIFIER_MULTIBROADCAST;
5053 ie.ie_EventAddress=0;
5054 ie.ie_TimeStamp=tv;
5055
5056 inputreq->io_Command = IND_WRITEEVENT;
5057 inputreq->io_Length = sizeof(struct InputEvent);
5058 inputreq->io_Data = &ie;
5059
5060 DoIO((struct IORequest *)inputreq);
5061
5062 CloseDevice((struct IORequest *)inputreq);
5063 }
5064 DeleteIORequest(inputreq);
5065 }
5066 DeleteMsgPort(inputport);
5067 }
5068 }
5069
5070
5071
5072 #if 0
5073
5074 () {
5075 struct ExtFileLock *lock;
5076
5077 lock=locklist;
5078
5079 while(lock!=0) {
5080 if((lock->bits & EFL_MODIFIED)!=0) {
5081 /* File belonging to this lock was modified. */
5082
5083 if(lock->gh!=0 && lock->curextent!=0) {
5084 BLCK lastblock=lock->curextent;
5085
5086 lastblock+=lock->extentoffset>>shifts_block;
5087
5088 /* lastblock is now possibly the last block which is used by the file. This
5089 should always be true for newly created files which are being extended. */
5090
5091
5092 }
5093 }
5094
5095 lock=lock->next;
5096 }
5097 }
5098
5099 #endif
5100
5101
5102 BOOL freeupspace(void) {
5103 BOOL spacefreed=FALSE;
5104
5105 /* This function tries to free up space. It does this by
5106 permanently deleting deleted files (if case of a recycled)
5107 and by flushing the current transaction if there is one.
5108
5109 If no space could be freed, then this function returns
5110 FALSE. This is the go-ahead sign to report disk full
5111 to the user. */
5112
5113 if(hastransaction()) {
5114 flushtransaction();
5115 spacefreed=TRUE;
5116 }
5117
5118 if(cleanupdeletedfiles()!=FALSE) {
5119 spacefreed=TRUE;
5120 }
5121
5122 return(spacefreed);
5123 }
5124
5125
5126
5127 LONG writetofile(struct ExtFileLock *lock, UBYTE *buffer, ULONG bytestowrite) {
5128 struct GlobalHandle *gh=lock->gh;
5129 LONG errorcode;
5130
5131 /* This function must be called from within a transaction! */
5132
5133 if((gh->protection & FIBF_WRITE)!=0) {
5134 ULONG maxbytes;
5135 LONG newbytes;
5136
5137 /* First thing we need to do is extend the file (if needed) to
5138 accomodate for all the data we are about to write. */
5139
5140 maxbytes=(gh->size + globals->bytes_block-1) & ~globals->mask_block; // Maximum number of bytes file can hold with the current amount of blocks.
5141 newbytes=bytestowrite-(maxbytes-lock->offset); // Number of new bytes which would end up in newly allocated blocks.
5142
5143 if((errorcode=seektocurrent(lock))==0 && (newbytes<=0 || (errorcode=extendblocksinfile(lock, (newbytes+globals->bytes_block-1)>>globals->shifts_block))==0)) {
5144 struct CacheBuffer *extent_cb;
5145 struct fsExtentBNode *ebn=0;
5146 ULONG newfilesize;
5147
5148 /* At this point, the file either didn't need extending, or was succesfully extended. */
5149
5150 newfilesize=lock->offset+bytestowrite;
5151
5152 if(newfilesize<gh->size) {
5153 newfilesize=gh->size;
5154 }
5155
5156 /* If the filesize will change, then we set it below */
5157
5158 if(newfilesize!=gh->size) {
5159 struct CacheBuffer *cb;
5160 struct fsObject *o;
5161
5162 if((errorcode=readobject(lock->objectnode,&cb,&o))==0) {
5163 preparecachebuffer(cb);
5164
5165 checksum_writelong_be(cb->data, &o->object.file.be_size, newfilesize);
5166 gh->size=newfilesize;
5167
5168 if(o->object.file.be_data==0) {
5169 checksum_writelong_be(cb->data, &o->object.file.be_data, lock->curextent);
5170 gh->data=lock->curextent;
5171 }
5172
5173 errorcode=storecachebuffer_nochecksum(cb);
5174 }
5175 }
5176
5177 if(errorcode==0) {
5178 while(bytestowrite!=0 && (errorcode=findextentbnode(lock->curextent, &extent_cb, &ebn))==0) {
5179 ULONG bytes;
5180 ULONG offsetinblock=lock->extentoffset & globals->mask_block;
5181 BLCK ebn_next=BE2L(ebn->be_next);
5182 UWORD ebn_blocks=BE2W(ebn->be_blocks);
5183
5184 if(BE2W(ebn->be_blocks)==lock->extentoffset>>globals->shifts_block) {
5185 /* We are at the end +1 of this extent. Skip to next one. */
5186
5187 lock->curextent=BE2L(ebn->be_next);
5188 lock->extentoffset=0;
5189 continue;
5190 }
5191
5192 if(offsetinblock!=0 || bytestowrite<globals->bytes_block) {
5193
5194 /** Partial writes to the last block of the file will cause a
5195 read of that block, even if this block didn't yet contain
5196 any valid data, because the file was just extended. This
5197 is unneeded... */
5198
5199 /* File-ptr is located somewhere in the middle of a block, or at the
5200 start of the block but not at the end of the file. To add data
5201 to it we'll first need to read this block. */
5202
5203 _XDEBUG((DEBUG_IO,"writetofile: Partially overwriting a single block of a file. ebn->key = %ld, lock->extentoffset = %ld\n",BE2L(ebn->be_key),lock->extentoffset));
5204
5205 bytes=globals->bytes_block-offsetinblock;
5206
5207 if(bytes>bytestowrite) {
5208 bytes=bytestowrite;
5209 }
5210
5211 // if(newbytes>0 && offsetinblock==0) { /** offsetinblock check is NOT redundant. */
5212 // struct CacheBuffer *cb=getcachebuffer();
5213 //
5214 // CopyMem(buffer, cb->data, bytes);
5215 // errorcode=writethrough(lock->curextent + (lock->extentoffset>>shifts_block), cb->data, 1);
5216 // emptycachebuffer(cb);
5217 //
5218 // if(errorcode!=0) {
5219 // break;
5220 // }
5221 // }
5222 // else {
5223 if((errorcode=writebytes(BE2L(ebn->be_key)+(lock->extentoffset>>globals->shifts_block), buffer, offsetinblock, bytes))!=0) {
5224 break;
5225 }
5226 // }
5227 }
5228 else {
5229 bytes=(((ULONG)ebn_blocks)<<globals->shifts_block) - lock->extentoffset;
5230
5231 if(bytes > bytestowrite) {
5232 bytes=bytestowrite & ~globals->mask_block;
5233
5234 /** This is a hack to speed up writes.
5235
5236 What it does is write more bytes than there are in the buffer
5237 available (runaway writing), to avoid a seperate partial block
5238 write. It makes sure the extra data written doesn't extend
5239 into a new 4K page (assuming MMU is using 4K pages). */
5240
5241 // #define MMU_PAGESIZE (524288)
5242 //
5243 // if(((ULONG)(buffer+bytes) & ~(MMU_PAGESIZE-1))==((ULONG)(buffer+bytes+bytes_block-1) & ~(MMU_PAGESIZE-1))) {
5244 // bytes=bytestowrite;
5245 // }
5246 }
5247
5248 // _XDEBUG((DEBUG_IO,"writetofile: Writing multiple blocks: blockstowrite = %ld, ebn->key = %ld, lock->extentoffset = %ld, lock->offset = %ld\n",blockstowrite, ebn->key, lock->extentoffset, lock->offset));
5249
5250 if((errorcode=write(BE2L(ebn->be_key)+(lock->extentoffset>>globals->shifts_block), buffer, (bytes+globals->bytes_block-1)>>globals->shifts_block))!=0) {
5251 break;
5252 }
5253 }
5254
5255 seekforward(lock, ebn_blocks, ebn_next, bytes);
5256
5257 bytestowrite-=bytes;
5258 buffer+=bytes;
5259 }
5260 }
5261 }
5262 }
5263 else {
5264 errorcode=ERROR_WRITE_PROTECTED;
5265 }
5266
5267 return(errorcode);
5268 }
5269
5270
5271
5272 LONG deletefileslowly(struct CacheBuffer *cbobject, struct fsObject *o) {
5273 ULONG size=BE2L(o->object.file.be_size);
5274 ULONG key=BE2L(o->object.file.be_data);
5275 LONG errorcode=0;
5276
5277 /* cbobject & o refer to the file to be deleted (don't use this for objects
5278 other than files!). The file is deleted a piece at the time. This is
5279 because then even in low space situations files can be deleted.
5280
5281 Note: This function deletes an object without first checking if
5282 this is allowed. Use deleteobject() instead. */
5283
5284 _DEBUG(("deletefileslowly: Entry\n"));
5285
5286 /* First we search for the last ExtentBNode */
5287
5288 if(key!=0) {
5289 struct CacheBuffer *cb;
5290 struct fsExtentBNode *ebn;
5291 ULONG currentkey=0, prevkey=0;
5292 ULONG blocks=0;
5293
5294 lockcachebuffer(cbobject);
5295
5296 while((errorcode=findbnode(globals->block_extentbnoderoot,key,&cb,(struct BNode **)&ebn))==0) {
5297 if(BE2L(ebn->be_next)==0) {
5298 currentkey=BE2L(ebn->be_key);
5299 prevkey=BE2L(ebn->be_prev);
5300 blocks=BE2W(ebn->be_blocks);
5301 break;
5302 }
5303 key=BE2L(ebn->be_next);
5304 }
5305
5306 /* Key could be zero (in theory) or contains the last ExtentBNode for this file. */
5307
5308 if(errorcode==0) {
5309 while((key & 0x80000000)==0) {
5310 key=prevkey;
5311
5312 newtransaction();
5313
5314 lockcachebuffer(cb); /* Makes sure freespace() doesn't reuse this cachebuffer */
5315
5316 if((errorcode=freespace(currentkey, blocks))==0) {
5317 unlockcachebuffer(cb);
5318
5319 if((errorcode=deletebnode(globals->block_extentbnoderoot, currentkey))==0) {
5320 if((key & 0x80000000)==0) {
5321 if((errorcode=findbnode(globals->block_extentbnoderoot, key, &cb, (struct BNode **)&ebn))==0) {
5322 preparecachebuffer(cb);
5323
5324 ebn->be_next=0;
5325 currentkey=BE2L(ebn->be_key);
5326 prevkey=BE2L(ebn->be_prev);
5327 blocks=BE2W(ebn->be_blocks);
5328
5329 errorcode=storecachebuffer(cb);
5330 }
5331 }
5332 else {
5333 preparecachebuffer(cbobject);
5334
5335 checksum_writelong_be(cbobject->data, &o->object.file.be_size, 0);
5336 checksum_writelong_be(cbobject->data, &o->object.file.be_data, 0);
5337
5338 // o->object.file.data=0;
5339 // o->object.file.size=0;
5340
5341 if((errorcode=storecachebuffer_nochecksum(cbobject))==0) {
5342 errorcode=setrecycledinfodiff(0, -((size+globals->bytes_block-1)>>globals->shifts_block));
5343 }
5344 }
5345 }
5346 }
5347 else {
5348 unlockcachebuffer(cb);
5349 }
5350
5351 if(errorcode==0) {
5352 /* Unlocked CacheBuffers could be killed after an endtransaction()! */
5353 endtransaction();
5354 }
5355 else {
5356 deletetransaction();
5357 break;
5358 }
5359 }
5360 }
5361
5362 unlockcachebuffer(cbobject);
5363 }
5364
5365 _DEBUG(("deletefileslowly: Alternative way errorcode = %ld\n",errorcode));
5366
5367 if(errorcode==0) {
5368
5369 /* File-data was succesfully freed. Now remove the empty object. */
5370
5371 newtransaction();
5372
5373 if((errorcode=removeobject(cbobject, o))==0) {
5374 endtransaction();
5375 return(0);
5376 }
5377
5378 deletetransaction();
5379 }
5380
5381 _DEBUG(("deletefileslowly: Exiting with errorcode = %ld\n",errorcode));
5382
5383 return(errorcode);
5384 }
5385
5386
5387 /*
5388
5389 Transactions
5390 ------------
5391
5392 ReadCacheBuffer
5393 ReadOriginalCacheBuffer
5394 LockCacheBuffer
5395 UnLockCacheBuffer
5396 NewTransaction
5397 DeleteTransaction
5398 EndTransaction
5399 StoreCacheBuffer
5400 PrepareCacheBuffer
5401
5402 The transaction system allows the filesystem to keep track
5403 of changes made to blocks in the cache. Every change is
5404 stored in a transaction buffer. The transaction buffer and
5405 the original version of a block can be used to restore the
5406 latest version of a block at any time.
5407
5408 At any time you can use readcachebuffer() to get the latest
5409 version of a block. This could be a partially modified
5410 version if you're in the middle of a transaction, the latest
5411 version stored in the transaction buffer or the original
5412 version from disk.
5413
5414 When you want to make changes to a block you call
5415 preparecachebuffer(). This checks if the block you're
5416 preparing to change is the original version, and if so makes
5417 a backup copy. This copy is not strictly needed, but it
5418 speeds up the filesystem to keep the original version around
5419 in case we need it later. The preparecachebuffer() function
5420 also calls lockcachebuffer() so the block you're changing
5421 won't be reused in subsequent cache operations.
5422
5423 When you're satisfied with the changes you've made to a
5424 specific block you should call storecachebuffer(). This
5425 stores the changes into the transaction buffer. From that
5426 point on readcachebuffer() will be able to recreate the
5427 block with your new modifications.
5428
5429 Before calling preparecachebuffer() for the first time, you
5430 need to call newtransaction(). This is to let the
5431 transaction system know you're about to start a new series
5432 of modifications.
5433
5434 When you're done making all the changes to multiple blocks
5435 you need to call endtransaction(). This makes all the
5436 changes permanent. If there was an error along the way you
5437 can call deletetransaction() and all the changes you stored
5438 with storecachebuffer() since you're last call to
5439 newtransaction() will automatically be discarded.
5440
5441 Any cachebuffers you had locked at the time which had
5442 changes in them will be restored to their original state (in
5443 reality these buffers will simply be reread using
5444 readcachebuffer()).
5445
5446 Examples:
5447
5448 x=readcachebuffer(0); // x.data = 1
5449
5450 newtransaction();
5451
5452 preparecachebuffer(x);
5453
5454 x.data=2;
5455
5456 storecachebuffer(cb);
5457
5458 deletetransaction(); // x.data = 1;
5459
5460 read(x) -> "AA"; newtr(); prep(x); write("CC") -> "CC"; store(x); endtr() -> "CC";
5461
5462 read(x) -> "AA"; newtr(); prep(x); write("CC") -> "CC"; store(x); deltr() -> "AA";
5463
5464 read(x) -> "AA"; newtr(); prep(x); write("CC") -> "CC"; store(x); newtr(); prep(x); write("EE") -> "EE"; store(x); deltr() -> "CC"; deltr() -> "AA";
5465
5466 */
5467
5468
5469
5470
5471
5472 LONG setnextextent(BLCK next, BLCK key) {
5473 struct CacheBuffer *cb;
5474 struct fsExtentBNode *ebn;
5475 LONG errorcode=0;
5476
5477 /* This function set the previous value of the
5478 passed Extent. If the passed Extent is zero
5479 then this function does nothing. */
5480
5481 if(next!=0 && (errorcode=findextentbnode(next, &cb, &ebn))==0) {
5482 preparecachebuffer(cb);
5483
5484 ebn->be_prev=L2BE(key);
5485
5486 errorcode=storecachebuffer(cb);
5487 }
5488
5489 return(errorcode);
5490 }
5491
5492
5493
5494 LONG setprevextent(BLCK prev, BLCK key) {
5495 struct CacheBuffer *cb;
5496 struct fsExtentBNode *ebn;
5497 LONG errorcode;
5498
5499 /* This function sets the next value of the
5500 passed Extent/Object to key. */
5501
5502 if((prev & 0x80000000)==0 && (errorcode=findextentbnode(prev, &cb, &ebn))==0) {
5503 preparecachebuffer(cb);
5504
5505 ebn->be_next=L2BE(key);
5506
5507 errorcode=storecachebuffer(cb);
5508 }
5509 else {
5510 struct fsObject *o;
5511
5512 if((errorcode=readobject((prev & 0x7fffffff), &cb, &o))==0) {
5513 preparecachebuffer(cb);
5514
5515 o->object.file.be_data=L2BE(key);
5516
5517 errorcode=storecachebuffer(cb);
5518 }
5519 }
5520
5521 return(errorcode);
5522 }
5523
5524
5525
5526 LONG mergeextent(BLCK key) {
5527 struct CacheBuffer *cb;
5528 struct fsExtentBNode *ebn;
5529 LONG errorcode;
5530
5531 /* This function tries to merge the current extent with the
5532 next extent. If the extent can't be merged, or was
5533 succesfully merged then this function returns 0. Any
5534 error which occured during merging will be returned. */
5535
5536 if((errorcode=findextentbnode(key, &cb, &ebn))==0) {
5537
5538 /* We check if we found the right key, if there is a next Extent and
5539 if the two Extents touch each other: */
5540
5541 if(BE2L(ebn->be_key)==key && BE2L(ebn->be_next)!=0 && BE2L(ebn->be_key)+BE2W(ebn->be_blocks) == BE2L(ebn->be_next)) {
5542 struct CacheBuffer *cb2;
5543 struct fsExtentBNode *ebn2;
5544
5545 if((errorcode=findextentbnode(BE2L(ebn->be_next), &cb2, &ebn2))==0 && BE2W(ebn2->be_blocks)+BE2W(ebn->be_blocks) < 65536) {
5546 BLCK next=BE2L(ebn2->be_next);
5547
5548 /* Merge next extent with our extent */
5549
5550 preparecachebuffer(cb);
5551
5552 ebn->be_blocks=W2BE(BE2W(ebn->be_blocks)+BE2W(ebn2->be_blocks));
5553 ebn->be_next=L2BE(next);
5554
5555 if((errorcode=storecachebuffer(cb))==0) { // call storecachebuffer() here, because deletebnode() may move our BNode.
5556
5557 if((errorcode=deletebnode(globals->block_extentbnoderoot, BE2L(ebn2->be_key)))==0) { /*** Maybe use deleteinternalnode here??? */
5558 errorcode=setnextextent(next, key);
5559 }
5560 }
5561 }
5562 }
5563 }
5564
5565 return(errorcode);
5566 }
5567
5568
5569
5570 LONG insertextent(BLCK key, BLCK next, BLCK prev, ULONG blocks) {
5571 struct CacheBuffer *cb=0;
5572 struct fsExtentBNode *ebn=0;
5573 LONG errorcode;
5574
5575 /* This function creates a new extent, but won't create one if it can
5576 achieve the same effect by extending the next or previous extent.
5577 In the unlikely case that the new extent is located EXACTLY between
5578 its predecessor and successor then an attempt will be made to merge
5579 these 3 extents into 1. */
5580
5581 /*
5582 prev available & mergeable -> merge.
5583 prev available, but not mergeable -> create new -> update next -> update previous.
5584 prev not available -> create new -> update next -> update object
5585 */
5586
5587 if((prev & 0x80000000)!=0 || (errorcode=findextentbnode(prev, &cb, &ebn))==0) {
5588
5589 if((prev & 0x80000000)==0 && prev+BE2W(ebn->be_blocks) == key && BE2W(ebn->be_blocks)+blocks < 65536) {
5590
5591 /* Extent we are inserting is mergeable with its previous extent. */
5592
5593 preparecachebuffer(cb);
5594
5595 ebn->be_blocks=W2BE(BE2W(ebn->be_blocks)+blocks); /* This merges the previous and the new extent */
5596
5597 if((errorcode=storecachebuffer(cb))==0) {
5598 errorcode=mergeextent(BE2L(ebn->be_key));
5599 }
5600 }
5601 else {
5602
5603 /* Extent we are inserting couldn't be merged with its previous extent. */
5604
5605 if((errorcode=setprevextent(prev, key))==0 && (errorcode=createextentbnode(key, &cb, &ebn))==0) {
5606
5607 /* Succesfully updated previous extent, or the object. Also created new BNode */
5608
5609 ebn->be_key=L2BE(key);
5610 ebn->be_prev=L2BE(prev);
5611 ebn->be_next=L2BE(next);
5612 ebn->be_blocks=BE2W(blocks);
5613
5614 if((errorcode=storecachebuffer(cb))==0) {
5615 if((errorcode=setnextextent(next, key))==0) {
5616 mergeextent(key);
5617 }
5618 }
5619 }
5620 }
5621 }
5622
5623 return(errorcode);
5624 }
5625
5626
5627
5628 LONG truncateextent(BLCK key, LONG blocks) {
5629 struct CacheBuffer *cb;
5630 struct fsExtentBNode *ebn;
5631 LONG errorcode=0;
5632
5633 /* Truncates the extended by the given amount of blocks.
5634 If the amount is negative then the truncation occurs
5635 at the start, otherwise at the end.
5636
5637 This function returns INTERR_EXTENT if you tried to
5638 truncate to zero blocks (or beyond). Any errorcode
5639 is returned. If blocks is zero, then this function
5640 does nothing.
5641
5642 Mar 20 1999: The truncation at the start could cause
5643 BNode's to get lost (because they are
5644 indexed by their start block). Fixed. */
5645
5646 if(blocks!=0) {
5647 if((errorcode=findextentbnode(key, &cb, &ebn))==0) {
5648 ULONG b;
5649
5650 b=blocks<0 ? -blocks : blocks;
5651
5652 if(b<BE2W(ebn->be_blocks) && BE2L(ebn->be_key)==key) {
5653 if(blocks<0) {
5654 ULONG next=BE2L(ebn->be_next);
5655 ULONG prev=BE2L(ebn->be_prev);
5656 UWORD blocks=BE2W(ebn->be_blocks)-b;
5657
5658 /* Truncating at the start. */
5659
5660 if((errorcode=deletebnode(globals->block_extentbnoderoot, key))==0) {
5661
5662 key+=b;
5663
5664 if((errorcode=createbnode(globals->block_extentbnoderoot, key, &cb, (struct BNode **)&ebn))==0) {
5665 ebn->be_key=L2BE(key);
5666 ebn->be_next=L2BE(next);
5667 ebn->be_prev=L2BE(prev);
5668 ebn->be_blocks=W2BE(blocks);
5669
5670 if((errorcode=storecachebuffer(cb))==0) {
5671 /* Truncating at start means changing the key value. This
5672 means that the next and previous BNode's must also be
5673 adjusted. */
5674
5675 if((errorcode=setnextextent(next, key))==0) {
5676 errorcode=setprevextent(prev, key);
5677 }
5678 }
5679 }
5680 }
5681 }
5682 else {
5683
5684 /* Truncating at the end. */
5685
5686 preparecachebuffer(cb);
5687
5688 ebn->be_blocks=W2BE(BE2W(ebn->be_blocks)-b);
5689
5690 errorcode=storecachebuffer(cb);
5691 }
5692 }
5693 else {
5694 errorcode=INTERR_EXTENT;
5695 }
5696 }
5697 }
5698
5699 return(errorcode);
5700 }
5701
5702
5703
5704 static LONG copy(BLCK source, BLCK dest, ULONG totblocks, UBYTE *optimizebuffer) {
5705 ULONG blocks;
5706 LONG errorcode=0;
5707
5708 /* Low-level function to copy blocks from one place to another. */
5709
5710 while(totblocks!=0) {
5711 blocks=totblocks;
5712 if(blocks > (OPTBUFSIZE>>globals->shifts_block)) {
5713 blocks=OPTBUFSIZE>>globals->shifts_block;
5714 }
5715
5716 if((errorcode=read(source, optimizebuffer, blocks))!=0) {
5717 break;
5718 }
5719
5720 if((errorcode=write(dest, optimizebuffer, blocks))!=0) {
5721 break;
5722 }
5723
5724 totblocks-=blocks;
5725 source+=blocks;
5726 dest+=blocks;
5727 }
5728
5729 return(errorcode);
5730 }
5731
5732
5733
5734 LONG deleteextent(struct CacheBuffer *cb, struct fsExtentBNode *ebn) {
5735 BLCK next,prev;
5736 LONG errorcode;
5737
5738 /* Deletes an fsExtentBNode structure and properly relinks the rest of the chain.
5739 No space will be given free.
5740
5741 newtransaction() should have been called prior to calling this function. */
5742
5743 next=BE2L(ebn->be_next);
5744 prev=BE2L(ebn->be_prev);
5745
5746 if((errorcode=deletebnode(globals->block_extentbnoderoot,BE2L(ebn->be_key)))==0) { /*** Maybe use deleteinternalnode here??? */
5747 if((errorcode=setnextextent(next, prev))==0) {
5748 errorcode=setprevextent(prev, next);
5749 }
5750 }
5751
5752 return(errorcode);
5753 }
5754
5755
5756
5757 static WORD enough_for_add_moved(void) {
5758 if(globals->defragmentlongs>5) {
5759 return TRUE;
5760 }
5761 return FALSE;
5762 }
5763
5764 static inline void add_moved(ULONG blocks, ULONG from, ULONG to) {
5765 if(globals->defragmentsteps!=0) {
5766 *globals->defragmentsteps++=AROS_LONG2BE(MAKE_ID('M','O','V','E'));
5767 *globals->defragmentsteps++=3;
5768 *globals->defragmentsteps++=blocks;
5769 *globals->defragmentsteps++=from;
5770 *globals->defragmentsteps++=to;
5771 *globals->defragmentsteps=0;
5772
5773 globals->defragmentlongs-=5;
5774 }
5775 }
5776
5777 static inline void add_done(void) {
5778 if(globals->defragmentsteps!=0) {
5779 *globals->defragmentsteps++=AROS_LONG2BE(MAKE_ID('D','O','N','E'));
5780 *globals->defragmentsteps++=0;
5781 *globals->defragmentsteps=0;
5782
5783 globals->defragmentlongs-=2;
5784 }
5785 }
5786
5787
5788
5789 LONG moveextent(struct fsExtentBNode *ebn, BLCK dest, UWORD blocks) {
5790 UBYTE *buf;
5791 LONG errorcode;
5792
5793 /* This function (partially) moves the Extent to /dest/.
5794 /blocks/ is the number of blocks moved; if blocks is
5795 equal to the size of the Extent, then the Extent will
5796 be deleted. Else the start of the Extent will be
5797 truncated. */
5798
5799 if((buf=AllocVec(OPTBUFSIZE, globals->bufmemtype))!=0) {
5800 BLCK key=BE2L(ebn->be_key);
5801 BLCK next=BE2L(ebn->be_next);
5802 BLCK prev=BE2L(ebn->be_prev);
5803 UWORD blocksinextent=BE2W(ebn->be_blocks);
5804
5805 if((errorcode=copy(key, dest, blocks, buf))==0) { // This functions knows that OPTBUFSIZE is the size of the buffer!
5806
5807 /* Data has been physically moved -- nothing has been
5808 permanently altered yet. */
5809
5810 if((errorcode=markspace(dest, blocks))==0) {
5811
5812 if((errorcode=freespace(key, blocks))==0) {
5813
5814 /* Bitmap has been altered to reflect the new location of the
5815 moved data. Now we either need to truncate the Extent (if
5816 it was partially moved) or remove it. */
5817
5818 if(blocksinextent==blocks) {
5819 struct CacheBuffer *cb;
5820
5821 if((errorcode=findextentbnode(key, &cb, &ebn))==0) {
5822 errorcode=deleteextent(cb, ebn);
5823 }
5824 }
5825 else {
5826 next=key+blocks;
5827 errorcode=truncateextent(key, -blocks);
5828 }
5829
5830 if(errorcode==0) {
5831 if((errorcode=insertextent(dest, next, prev, blocks))==0) {
5832 add_moved(blocks, key, dest);
5833 }
5834 }
5835 }
5836 }
5837 }
5838
5839 FreeVec(buf);
5840 }
5841 else {
5842 errorcode=ERROR_NO_FREE_STORE;
5843 }
5844
5845 return(errorcode);
5846 }
5847
5848
5849
5850 static LONG fillgap(BLCK key) {
5851 struct CacheBuffer *cb;
5852 struct fsExtentBNode *ebn;
5853 LONG errorcode;
5854
5855 /* This function will attempt to fill the gap behind an extent with
5856 data from the next extent. This in effect merges the extent and
5857 the next extent (partially). */
5858
5859 if((errorcode=findextentbnode(key, &cb, &ebn))==0) {
5860 ULONG next=BE2L(ebn->be_next);
5861
5862 key+=BE2W(ebn->be_blocks);
5863
5864 while(next!=0 && (errorcode=findextentbnode(next, &cb, &ebn))==0) { // !! failed !!
5865 UWORD blocks=BE2W(ebn->be_blocks);
5866 LONG free;
5867
5868 lockcachebuffer(cb);
5869
5870 if((free=availablespace(key, 1024))>0) {
5871
5872 unlockcachebuffer(cb);
5873
5874 _DEBUG(("fillgap: availablespace() returned %ld\n",free));
5875
5876 /* The gap consists of /free/ blocks. */
5877
5878 if(free > blocks && enough_for_add_moved()!=FALSE) {
5879 next=BE2L(ebn->be_next);
5880 }
5881 else {
5882 next=0;
5883 }
5884
5885 if((errorcode=moveextent(ebn, key, MIN(free, blocks)))!=0) {
5886 return(errorcode);
5887 }
5888
5889 key+=blocks;
5890 }
5891 else {
5892 unlockcachebuffer(cb);
5893 }
5894 }
5895 }
5896
5897 _DEBUG(("fillgap: exiting with errorcode %ld\n",errorcode));
5898
5899 return(errorcode);
5900 }
5901
5902
5903
5904 LONG getbnode(BLCK block, struct CacheBuffer **returned_cb, struct fsExtentBNode **returned_ebn) {
5905 LONG errorcode;
5906
5907 /* This function gets the ExtentBNode which starts at the given
5908 block or the first one after the given block. Zero *ebn indicates
5909 there were no ExtentBNode's at or after the given block. */
5910
5911 if((errorcode=findbnode(globals->block_extentbnoderoot, block, returned_cb, (struct BNode **)returned_ebn))==0) {
5912
5913 _DEBUG(("getbnode: ebn->key = %ld, ebn->prev = %ld, ebn->blocks = %ld\n",BE2L((*returned_ebn)->be_key), BE2L((*returned_ebn)->be_prev), BE2W((*returned_ebn)->be_blocks)));
5914
5915 if(*returned_ebn!=0 && BE2L((*returned_ebn)->be_key)<block) {
5916 errorcode=nextbnode(globals->block_extentbnoderoot, returned_cb, (struct BNode **)returned_ebn);
5917
5918 _DEBUG(("getbnode: 2: ebn->key = %ld, ebn->prev = %ld, ebn->blocks = %ld\n",BE2L((*returned_ebn)->be_key), BE2L((*returned_ebn)->be_prev), BE2W((*returned_ebn)->be_blocks)));
5919 }
5920 }
5921
5922 return(errorcode);
5923 }
5924
5925
5926
5927 #if 0
5928 LONG makefreespace(BLCK block) {
5929 struct CacheBuffer *cb;
5930 struct fsExtentBNode *ebn;
5931 LONG errorcode;
5932
5933 /* This function tries to move the data located at /block/ to
5934 another area of the disk. */
5935
5936 if((errorcode=findextentbnode(block, &cb, &ebn))==0) {
5937 ULONG blocks;
5938 ULONG newblocks;
5939 BLCK startblock;
5940
5941 lockcachebuffer(cb);
5942
5943 blocks=MIN(OPTBUFSIZE>>shifts_block, ebn->blocks);
5944
5945 if((errorcode=findspace2_backwards(blocks, block, blocks_total, &startblock, &newblocks))==0) {
5946 unlockcachebuffer(cb);
5947
5948 if(newblocks!=0) {
5949
5950 _DEBUG(("makefreespace: Looking for %ld blocks from block %ld, and found %ld blocks at block %ld.\n", blocks, block, newblocks, startblock));
5951
5952 errorcode=moveextent(ebn, startblock, newblocks);
5953 }
5954 else {
5955 errorcode=ERROR_DISK_FULL;
5956 }
5957 }
5958 else {
5959 unlockcachebuffer(cb);
5960 }
5961 }
5962
5963 return(errorcode);
5964 }
5965 #endif
5966
5967
5968 LONG makefreespace(BLCK block) {
5969 struct CacheBuffer *cb;
5970 struct fsExtentBNode *ebn;
5971 LONG errorcode;
5972 WORD count=0;
5973
5974 /* This function tries to move the data located at /block/ to
5975 another area of the disk. */
5976
5977 if((errorcode=findextentbnode(block, &cb, &ebn))==0) {
5978 do {
5979 ULONG blocks;
5980 ULONG newblocks;
5981 BLCK startblock;
5982
5983 lockcachebuffer(cb);
5984
5985 blocks=MIN(OPTBUFSIZE>>globals->shifts_block, BE2W(ebn->be_blocks));
5986
5987 if((errorcode=findspace2_backwards(blocks, BE2L(ebn->be_key), globals->blocks_total, &startblock, &newblocks))==0) { // ebn->key should not be changed to block.
5988 unlockcachebuffer(cb);
5989
5990 if(newblocks!=0) {
5991
5992 _DEBUG(("makefreespace: Looking for %ld blocks from block %ld, and found %ld blocks at block %ld.\n", blocks, block, newblocks, startblock));
5993
5994 if((errorcode=moveextent(ebn, startblock, newblocks))!=0) {
5995 break;
5996 }
5997 }
5998 else {
5999 if(count==0) {
6000 errorcode=ERROR_DISK_FULL;
6001 }
6002 break;
6003 }
6004 }
6005 else {
6006 unlockcachebuffer(cb);
6007 break;
6008 }
6009
6010 if(count++>=1) {
6011 break;
6012 }
6013
6014 if((errorcode=getbnode(block, &cb, &ebn))!=0 || ebn==0) {
6015 break;
6016 }
6017
6018 } while((BE2L(ebn->be_prev) & 0x80000000)==0);
6019 }
6020
6021 return(errorcode);
6022 }
6023
6024
6025
6026 LONG skipunmoveable(BLCK block) {
6027 struct CacheBuffer *cb;
6028 struct fsExtentBNode *ebn;
6029
6030 /* This function looks for moveable data or free space starting
6031 from the given block. It returns -1 in case of failure, or
6032 the first moveable block it finds. If there ain't no more
6033 moveable blocks, then blocks_total is returned. */
6034
6035 if((findbnode(globals->block_extentbnoderoot, block, &cb, (struct BNode **)&ebn))==0) {
6036 if(ebn!=0 && ebn->be_key==L2BE(block)) {
6037 return((LONG)block);
6038 }
6039 else if(ebn==0 || BE2L(ebn->be_key)>=block || nextbnode(globals->block_extentbnoderoot, &cb, (struct BNode **)&ebn)==0) {
6040 if(ebn!=0) {
6041 BLCK key=BE2L(ebn->be_key);
6042 LONG used;
6043
6044 /* Found something moveable, but maybe there was some free space before the
6045 moveable Extent. */
6046
6047 if((used=allocatedspace(block, key-block))!=-1) {
6048 if(block+used<key) {
6049 return((LONG)block+used);
6050 }
6051 else {
6052 return((LONG)key);
6053 }
6054 }
6055 }
6056 else {
6057 LONG errorcode;
6058
6059 if((errorcode=findspace(1, block, globals->blocks_total, &block))==0) {
6060 return((LONG)block);
6061 }
6062 else if(errorcode==ERROR_DISK_FULL) {
6063 return((LONG)globals->blocks_total);
6064 }
6065 }
6066 }
6067 }
6068
6069 return(-1);
6070 }
6071
6072
6073 struct fsExtentBNode *startofextentbnodechain(struct fsExtentBNode *ebn) {
6074 struct CacheBuffer *cb;
6075 LONG errorcode=0;
6076
6077 while((BE2L(ebn->be_prev) & 0x80000000)==0 && (errorcode=findextentbnode(BE2L(ebn->be_prev), &cb, &ebn))==0) {
6078 }
6079
6080 if(errorcode==0) {
6081 return(ebn);
6082 }
6083
6084 return(0);
6085 }
6086
6087
6088
6089 #if 0
6090 LONG findmatch(BLCK startblock, ULONG blocks, ULONG *bestkey) {
6091 struct CacheBuffer *cb;
6092 struct fsExtentBNode *ebn;
6093 // struct fsExtentBNode *ebn_start;
6094 ULONG bestblocks=0;
6095 LONG errorcode;
6096
6097 /* This function looks for the start of a ExtentBNode chain
6098 which matches the given size. If none is found, then the
6099 next smaller chain is returned. If none is found, then a
6100 larger chain is returned. If there are no chains at all
6101 0 is returned.
6102
6103 The first ExtentBNode examined is determined by the start
6104 block number which is passed. */
6105
6106 _DEBUG(("findmatch: Looking for a chain of %ld blocks starting from block %ld\n", blocks, startblock));
6107
6108 *bestkey=0;
6109
6110 if((errorcode=getbnode(startblock, &cb, &ebn))==0 && ebn!=0) {
6111
6112 _DEBUG(("findmatch: 1, ebn->key = %ld, ebn->blocks = %ld\n", ebn->key, ebn->blocks));
6113
6114 do {
6115 struct CacheBuffer *cb2;
6116 struct fsExtentBNode *ebn_start=ebn;
6117 struct fsObject *o;
6118 ULONG total=ebn->blocks; /* If larger than bestblocks, then we can stop looking for the start of the ExtentBNode chain early. */
6119 ULONG key, newblocks;
6120
6121 lockcachebuffer(cb);
6122 // ebn_start=startofextentbnodechain(ebn);
6123 {
6124 struct CacheBuffer *cb;
6125
6126 while((total<bestblocks || bestblocks==0) && (ebn_start->prev & 0x80000000)==0 && ebn_start->prev >= ebn->key && (errorcode=findextentbnode(ebn_start->prev, &cb, &ebn_start))==0) {
6127 total+=ebn_start->blocks;
6128 }
6129 }
6130 unlockcachebuffer(cb);
6131
6132 if(errorcode!=0) {
6133 break;
6134 }
6135
6136 if((total<bestblocks || bestblocks==0) && (ebn_start->prev & 0x80000000)!=0) {
6137
6138 _DEBUG(("findmatch: 2, ebn->key = %ld\n", ebn->key));
6139
6140 key=ebn_start->key;
6141
6142 lockcachebuffer(cb);
6143 errorcode=readobject(ebn_start->prev & 0x7FFFFFFF, &cb2, &o);
6144 unlockcachebuffer(cb);
6145
6146 if(errorcode!=0) {
6147 break;
6148 }
6149
6150 _DEBUG(("findmatch: 3, filesize = %ld\n",o->object.file.size));
6151
6152 newblocks=(o->object.file.size+bytes_block-1)>>shifts_block;
6153
6154 if(newblocks==blocks) { /* Found ideal match */
6155 *bestkey=key;
6156 break;
6157 }
6158 else if(newblocks<blocks) {
6159 if(newblocks>bestblocks || bestblocks>blocks) {
6160 *bestkey=key;
6161 bestblocks=newblocks;
6162 }
6163 }
6164 else if(bestblocks==0 || newblocks<bestblocks) {
6165 *bestkey=key;
6166 bestblocks=newblocks;
6167 }
6168 }
6169
6170 } while((errorcode=nextbnode(block_extentbnoderoot, &cb, (struct BNode **)&ebn))==0 && ebn!=0);
6171 }
6172
6173 return(errorcode);
6174 }
6175 #endif
6176
6177
6178
6179
6180 void newfragmentinit_large(ULONG blocks) {
6181 globals->bestkey=0;
6182 globals->bestblocks=0;
6183 globals->searchedblocks=blocks;
6184 }
6185
6186
6187
6188 ULONG newfragment_large(ULONG block, ULONG blocks) {
6189 if(blocks==globals->searchedblocks) { /* Found ideal match */
6190 return(block);
6191 }
6192 else if(blocks<globals->searchedblocks) {
6193 if(blocks>globals->bestblocks || globals->bestblocks>globals->searchedblocks) {
6194 globals->bestkey=block;
6195 globals->bestblocks=blocks;
6196 }
6197 }
6198 else if(globals->bestblocks==0 || blocks<globals->bestblocks) {
6199 globals->bestkey=block;
6200 globals->bestblocks=blocks;
6201 }
6202
6203 return(0);
6204 }
6205
6206
6207
6208 #if 0
6209 ULONG newfragment_large(ULONG block, ULONG blocks, UBYTE type) {
6210 if(type==0) {
6211 if(blocks==searchedblocks) { /* Found ideal match */
6212 return(block);
6213 }
6214 else if(blocks<searchedblocks) {
6215 if(blocks>bestblocks || bestblocks>searchedblocks) {
6216 bestkey=block;
6217 bestblocks=blocks;
6218 }
6219 }
6220 else if(bestblocks==0 || blocks<bestblocks) {
6221 bestkey=block;
6222 bestblocks=blocks;
6223 }
6224 }
6225
6226 return(0);
6227 }
6228 #endif
6229
6230
6231 ULONG newfragmentend_large(void) {
6232 return(globals->bestkey);
6233 }
6234
6235
6236
6237
6238 void newfragmentinit_small(ULONG blocks) {
6239 ULONG *f=globals->fragment;
6240 WORD n=FRAGMENTS;
6241
6242 newfragmentinit_large(blocks);
6243
6244 while(--n>=0) {
6245 *f++=0;
6246 }
6247 }
6248
6249
6250
6251
6252
6253 /*
6254 void newfragmentinit_small(ULONG blocks) {
6255 ULONG *f=fragment;
6256 UBYTE *fb=fragmenttype;
6257 WORD n=FRAGMENTS;
6258
6259 newfragmentinit_large(blocks);
6260
6261 while(--n>=0) {
6262 *f++=0;
6263 *fb++=0;
6264 }
6265 }
6266
6267
6268
6269 ULONG newfragment_small(ULONG block, ULONG blocks, UBYTE type) {
6270 if(blocks<searchedblocks) {
6271 if(fragment[blocks]==0 || (fragmenttype[blocks]!=0 && type==0)) {
6272 ULONG blocks2=searchedblocks-blocks;
6273
6274 fragment[blocks]=block;
6275 fragmenttype[blocks]=type;
6276
6277 if(blocks2==blocks) {
6278 blocks2=0;
6279 }
6280
6281 if(fragment[blocks2]!=0) {
6282 if(fragmenttype[blocks]==0 && fragmenttype[blocks2]==0) {
6283 return(fragment[blocks]);
6284 }
6285 }
6286 }
6287 }
6288
6289 return(newfragment_large(block, blocks, type));
6290 }
6291 */
6292
6293
6294
6295 ULONG newfragment_small(ULONG block, ULONG blocks) {
6296 if(blocks<globals->searchedblocks && globals->fragment[blocks]==0) {
6297 ULONG blocks2=globals->searchedblocks-blocks;
6298
6299 globals->fragment[blocks]=block;
6300
6301 if(blocks2==blocks) {
6302 blocks2=0;
6303 }
6304
6305 if(globals->fragment[blocks2]!=0) {
6306 return(globals->fragment[blocks]);
6307 }
6308 }
6309
6310 return(newfragment_large(block, blocks));
6311 }
6312
6313
6314
6315 ULONG newfragmentend_small(void) {
6316 return(newfragmentend_large());
6317 }
6318
6319
6320
6321
6322 #if 0
6323 LONG findmatch(BLCK startblock, ULONG blocks, ULONG *bestkey) {
6324 struct CacheBuffer *cb;
6325 struct fsExtentBNode *ebn;
6326 ULONG lastextentend=0;
6327 LONG maxscan=defrag_maxfilestoscan;
6328 LONG errorcode;
6329
6330 /* This function looks for the start of a ExtentBNode chain
6331 which matches the given size. If none is found, then the
6332 next smaller chain is returned. If none is found, then a
6333 larger chain is returned. If there are no chains at all
6334 0 is returned.
6335
6336 The first ExtentBNode examined is determined by the start
6337 block number which is passed. */
6338
6339 _DEBUG(("findmatch: Looking for a chain of %ld blocks starting from block %ld\n", blocks, startblock));
6340
6341 *bestkey=0;
6342
6343 if(blocks>FRAGMENTS-1) {
6344 newfragmentinit_large(blocks);
6345 }
6346 else {
6347 newfragmentinit_small(blocks);
6348 }
6349
6350 if((errorcode=getbnode(startblock, &cb, &ebn))==0 && ebn!=0) {
6351
6352 _DEBUG(("findmatch: ebn->key = %ld, ebn->blocks = %ld\n", ebn->key, ebn->blocks));
6353
6354 do {
6355 if((ebn->prev & 0x80000000)!=0) {
6356 struct CacheBuffer *cb2;
6357 struct fsObject *o;
6358 ULONG newblocks;
6359 UBYTE fragmenttype;
6360
6361 /* Found the start of a candidate chain. */
6362
6363 lockcachebuffer(cb);
6364 errorcode=readobject(ebn->prev & 0x7FFFFFFF, &cb2, &o);
6365 unlockcachebuffer(cb);
6366
6367 if(errorcode!=0) {
6368 break;
6369 }
6370
6371 newblocks=(o->object.file.size+bytes_block-1)>>shifts_block;
6372
6373 fragmenttype=lastextentend==ebn->key ? 1 : 0;
6374
6375 if(blocks>FRAGMENTS-1) {
6376 *bestkey=newfragment_large(ebn->key, newblocks, fragmenttype);
6377 }
6378 else {
6379 *bestkey=newfragment_small(ebn->key, newblocks, fragmenttype);
6380 }
6381
6382 if(*bestkey!=0) {
6383 return(0);
6384 }
6385
6386 if(--maxscan<0) {
6387 break;
6388 }
6389
6390 lastextentend=ebn->next==0 ? ebn->key + ebn->blocks : 0;
6391 }
6392 } while((errorcode=nextbnode(block_extentbnoderoot, &cb, (struct BNode **)&ebn))==0 && ebn!=0);
6393
6394 if(errorcode==0) {
6395 if(blocks>FRAGMENTS-1) {
6396 *bestkey=newfragmentend_large();
6397 }
6398 else {
6399 *bestkey=newfragmentend_small();
6400 }
6401 }
6402 }
6403
6404 return(errorcode);
6405 }
6406 #endif
6407
6408
6409
6410 LONG findmatch_fromend(BLCK startblock, ULONG blocks, ULONG *bestkey) {
6411 struct CacheBuffer *cb;
6412 struct fsExtentBNode *ebn;
6413 LONG maxscan=globals->defrag_maxfilestoscan;
6414 LONG errorcode;
6415
6416 /* This function looks for the start of a ExtentBNode chain
6417 which matches the given size. If none is found, then the
6418 next smaller chain is returned. If none is found, then a
6419 larger chain is returned. If there are no chains at all
6420 0 is returned.
6421
6422 The first ExtentBNode examined is determined by the start
6423 block number which is passed. */
6424
6425 _DEBUG(("findmatch_fromend: Looking for a chain of %ld blocks starting from block %ld\n", blocks, startblock));
6426
6427 *bestkey=0;
6428
6429 if(blocks>FRAGMENTS-1) {
6430 newfragmentinit_large(blocks);
6431 }
6432 else {
6433 newfragmentinit_small(blocks);
6434 }
6435
6436 if((errorcode=lastbnode(globals->block_extentbnoderoot, &cb, (struct BNode **)&ebn))==0 && ebn!=0 && BE2L(ebn->be_key)>=startblock) {
6437
6438 _DEBUG(("findmatch_fromend: ebn->key = %ld, ebn->blocks = %ld\n", BE2L(ebn->be_key), BE2W(ebn->be_blocks)));
6439
6440 do {
6441 if((BE2L(ebn->be_prev) & 0x80000000)!=0) { // Is this a 'first fragment' of something?
6442 struct CacheBuffer *cb2;
6443 struct fsObject *o;
6444 ULONG newblocks;
6445
6446 _DEBUG(("findmatch_fromend!: ebn->key = %ld, ebn->blocks = %ld\n", BE2L(ebn->be_key), BE2W(ebn->be_blocks)));
6447
6448 /* Found the start of a candidate chain. */
6449
6450 lockcachebuffer(cb);
6451 errorcode=readobject(BE2L(ebn->be_prev) & 0x7FFFFFFF, &cb2, &o);
6452 unlockcachebuffer(cb);
6453
6454 if(errorcode!=0) {
6455 break;
6456 }
6457
6458 newblocks=(BE2L(o->object.file.be_size)+globals->bytes_block-1)>>globals->shifts_block;
6459
6460 if(blocks>FRAGMENTS-1) {
6461 *bestkey=newfragment_large(BE2L(ebn->be_key), newblocks);
6462 }
6463 else {
6464 *bestkey=newfragment_small(BE2L(ebn->be_key), newblocks);
6465 }
6466
6467 if(*bestkey!=0) {
6468 return(0);
6469 }
6470
6471 if(--maxscan<0) {
6472 break;
6473 }
6474 }
6475 } while((errorcode=previousbnode(globals->block_extentbnoderoot, &cb, (struct BNode **)&ebn))==0 && ebn!=0 && BE2L(ebn->be_key)>=startblock);
6476
6477 if(errorcode==0) {
6478 if(blocks>FRAGMENTS-1) {
6479 *bestkey=newfragmentend_large();
6480 }
6481 else {
6482 *bestkey=newfragmentend_small();
6483 }
6484 }
6485 else {
6486 _DEBUG(("findmatch_fromend: errorcode=%ld\n", errorcode));
6487 }
6488 }
6489
6490 return(errorcode);
6491 }
6492
6493
6494
6495 LONG step(void) {
6496 LONG errorcode;
6497 LONG free;
6498
6499 if((free=availablespace(globals->block_defragptr, 256))!=-1) {
6500
6501 _DEBUG(("Defragmenter: Found %ld blocks of free space at block %ld.\n", free, globals->block_defragptr));
6502
6503 if(free==0) {
6504 struct CacheBuffer *cb;
6505 struct fsExtentBNode *ebn;
6506
6507 /* Determine in which extent block_defragptr is located. */
6508
6509 if((errorcode=findbnode(globals->block_extentbnoderoot, globals->block_defragptr, &cb, (struct BNode **)&ebn))==0) {
6510 if(ebn==0 || BE2L(ebn->be_key)!=globals->block_defragptr) {
6511 LONG block;
6512
6513 _DEBUG(("Defragmenter: Found unmoveable data at block %ld.\n", globals->block_defragptr));
6514
6515 /* Skip unmoveable data */
6516
6517 if((block=skipunmoveable(globals->block_defragptr))!=-1) {
6518 globals->block_defragptr=block;
6519 }
6520 else {
6521 errorcode=INTERR_DEFRAGMENTER;
6522 }
6523 }
6524 else if((BE2L(ebn->be_prev) & 0x80000000)!=0 || BE2L(ebn->be_prev)<globals->block_defragptr) {
6525
6526 _DEBUG(("Defragmenter: Found a (partially) defragmented extent at block %ld.\n", globals->block_defragptr));
6527
6528 if(BE2L(ebn->be_next)==0 || BE2L(ebn->be_next) == BE2L(ebn->be_key)+BE2W(ebn->be_blocks)) {
6529 /* If there is no next Extent, or if the next Extent is touching
6530 this one, then skip the current one. */
6531
6532 _DEBUG(("Defragmenter: Extent has no next or next is touching this one.\n"));
6533
6534 globals->block_defragptr+=BE2W(ebn->be_blocks);
6535 }
6536 else {
6537 LONG freeafter;
6538 BLCK key=BE2L(ebn->be_key);
6539 BLCK next=BE2L(ebn->be_next);
6540 UWORD blocks=BE2W(ebn->be_blocks);
6541
6542 _DEBUG(("Defragmenter: Extent has a next extent.\n"));
6543
6544 if((freeafter=availablespace(key+blocks, 256))!=-1) {
6545
6546 _DEBUG(("Defragmenter: There are %ld blocks of free space after the extent at block %ld.\n", freeafter, key));
6547
6548 if(freeafter>0) {
6549 /* Move (part of) data located in next extent to this free space. */
6550
6551 _DEBUG(("Defragmenter: Filling the gap.\n"));
6552
6553 /* The function below can be called multiple times in a row. When there is a large
6554 gap in which multiple extents of the file will fit, then these can all be transfered
6555 into the gap at once. */
6556
6557 errorcode=fillgap(key);
6558 }
6559 else {
6560 LONG block;
6561
6562 /* Determine which extent it is which is located directly after the current extent. */
6563
6564 if((block=skipunmoveable(key+blocks))!=-1) {
6565 if(block==key+blocks) {
6566
6567 _DEBUG(("Defragmenter: There was a moveable extent after the extent at block %ld.\n", key));
6568
6569 /* There was no unmoveable data, so let's move it. */
6570
6571 errorcode=makefreespace(block);
6572 }
6573 else {
6574 LONG freeafter;
6575
6576 _DEBUG(("Defragmenter: Skipped %ld blocks of unmoveable data.\n", block-(key+blocks)));
6577
6578 /* Unmoveable data was skipped. */
6579
6580 if(block!=next) { // Mar 20 1999: Check to see if the extent after the unmoveable data is not already the correct one.
6581
6582 if((freeafter=availablespace(block, 256))!=-1) {
6583
6584 _DEBUG(("Defragmenter: There are %ld blocks of free space after the unmoveable data.\n", freeafter));
6585
6586 if(freeafter==0) {
6587
6588 _DEBUG(("Defragmenter: Clearing some space at block %ld.\n", block));
6589
6590 if((errorcode=makefreespace(block))==0) {
6591 if((freeafter=availablespace(block, 256))==-1) {
6592 errorcode=INTERR_DEFRAGMENTER;
6593 }
6594
6595 _DEBUG(("Defragmenter: There are now %ld blocks of cleared space after the unmoveable data.\n", freeafter));
6596 }
6597 }
6598
6599 if(errorcode==0) {
6600 struct CacheBuffer *cb;
6601 struct fsExtentBNode *ebn;
6602
6603 if((errorcode=findextentbnode(next, &cb, &ebn))==0) {
6604
6605 _DEBUG(("Defragmenter: Moved next extent of our extent directly after the unmoveable space (block = %ld).\n", block));
6606
6607 if((errorcode=moveextent(ebn, block, MIN(freeafter, BE2W(ebn->be_blocks))))==0) {
6608 globals->block_defragptr=block;
6609 }
6610 }
6611 }
6612 }
6613 else {
6614 errorcode=INTERR_DEFRAGMENTER;
6615 }
6616 }
6617 else {
6618
6619 /* Extent after unmoveable data is already correct, so no need to move it. */
6620
6621 globals->block_defragptr=block;
6622 }
6623 }
6624 }
6625 else {
6626 errorcode=INTERR_DEFRAGMENTER;
6627 }
6628 }
6629 }
6630 else {
6631 errorcode=INTERR_DEFRAGMENTER;
6632 }
6633 }
6634 }
6635 else {
6636
6637 _DEBUG(("Defragmenter: Found an extent at block %ld which must be moved away.\n", globals->block_defragptr));
6638
6639 errorcode=makefreespace(globals->block_defragptr);
6640 }
6641 }
6642 }
6643 else {
6644 ULONG bestkey;
6645
6646 if((errorcode=findmatch_fromend(globals->block_defragptr, free, &bestkey))==0) {
6647 if(bestkey!=0) {
6648 struct CacheBuffer *cb;
6649 struct fsExtentBNode *ebn;
6650
6651 if((errorcode=findextentbnode(bestkey, &cb, &ebn))==0) {
6652
6653 _DEBUG(("Defragmenter: Moving a new first Extent to %ld\n", globals->block_defragptr));
6654
6655 errorcode=moveextent(ebn, globals->block_defragptr, MIN(free, BE2W(ebn->be_blocks)));
6656 }
6657 }
6658 else {
6659 _DEBUG(("Defragmenter: Nothing more to optimize.\n"));
6660
6661 add_done();
6662 }
6663 }
6664 }
6665 }
6666 else {
6667 errorcode=INTERR_DEFRAGMENTER;
6668 }
6669
6670 _DEBUG(("Defragmenter: Exiting with errorcode %ld\n\n",errorcode));
6671
6672 return(errorcode);
6673 }
6674
6675
6676
6677 /*
6678
6679 if (block at block_optimizeptr is full) {
6680
6681 determine in which extent block_optimizeptr is located.
6682
6683 if (not located in extent) {
6684 skip unmoveable data: add 1 to block_optimizeptr.
6685 }
6686 else if (extent is first extent OR previous extent is located before block_optimizeptr) {
6687 if (extent is last extent (as well)) {
6688 file was defragmented: set block_optimizeptr to point just after this extent.
6689 }
6690 else {
6691 determine if there is free space located after this extent.
6692
6693 if (there is free space) {
6694 move (part of) data located in next extent to this free space.
6695 }
6696 else {
6697
6698 determine which extent it is which is located directly after the current extent.
6699
6700 if (no such extent exists) {
6701 skip unmoveable data
6702
6703 if (no free space after unmoveable data) {
6704 make some free space by moving data.
6705 }
6706 move (part of) data located in next extent to the (newly made) free space: set block_optimizeptr in this part.
6707 }
6708 else {
6709 make some free space first by moving data.
6710 }
6711 }
6712 }
6713 }
6714 else {
6715 make some free space by moving data at block_optimizeptr.
6716 }
6717 }
6718 else {
6719
6720 determine amount of free space.
6721
6722 look for an extent-chain equal to the amount of free space beyond this location.
6723
6724 if (found suitable extent-chain) {
6725 move data to block_optimizeptr; set block_optimizeptr to point just after this data.
6726 }
6727 else {
6728 scan for ANY 'first' extent beyond this location.
6729
6730 if (none found) {
6731 optimization is done.
6732 }
6733 else {
6734 move found 'first' extent to block_optimizeptr.
6735 }
6736 }
6737 }
6738
6739
6740 */
6741
6742
6743 /* The simple purpose of the SFS DosList handler task is to
6744 provide the following non-blocking functions:
6745
6746 - Adding a VolumeNode to the DosList
6747 data = VolumeNode
6748
6749 - Removing a VolumeNode from the DosList (synchronously)
6750 data = VolumeNode
6751
6752 All messages send to the DosList handler are freed by
6753 the DosList handler itself. This is to avoid having to
6754 wait for the reply and then free the message yourself.
6755 */
6756
6757 #ifdef __AROS__
6758 #undef globals
6759 #else
6760 #undef SysBase
6761 #endif
6762 #undef DOSBase
6763
6764 static void sdlhtask(void)
6765 {
6766 #ifndef __AROS__
6767 struct ExecBase *SysBase=globals->sysBase;
6768 #endif
6769 struct DosLibrary *DOSBase;
6770
6771 if((DOSBase=(struct DosLibrary *)OpenLibrary("dos.library",37))!=0) {
6772 Forbid();
6773 if(FindPort("SFS DosList handler")==0) {
6774 struct MsgPort *port;
6775
6776 if((port=CreateMsgPort())!=0) {
6777 struct SFSMessage *sfsm;
6778
6779 port->mp_Node.ln_Name="SFS DosList handler";
6780 port->mp_Node.ln_Pri=1;
6781 AddPort(port);
6782 Permit();
6783
6784 for(;;) {
6785 struct DosList *dol;
6786
6787 WaitPort(port);
6788
6789 dol=LockDosList(LDF_WRITE|LDF_VOLUMES);
6790
6791 while((sfsm=(struct SFSMessage *)GetMsg(port))!=0) {
6792 if(sfsm->command==SFSM_ADD_VOLUMENODE) {
6793 /* AddDosEntry rejects volumes based on their name and date. */
6794
6795 if(AddDosEntry((struct DosList *)sfsm->data)==DOSFALSE) {
6796 sfsm->errorcode=IoErr();
6797 }
6798
6799 // if(AddDosEntry((struct DosList *)sfsm->data)==DOSFALSE) {
6800 // errorcode=IoErr();
6801 // FreeDosEntry((struct DosList *)vn);
6802 // vn=0;
6803 // }
6804 }
6805 else if(sfsm->command==SFSM_REMOVE_VOLUMENODE) {
6806 struct DosList *vn=(struct DosList *)sfsm->data;
6807
6808 while((dol=NextDosEntry(dol, LDF_VOLUMES))!=0) {
6809 if(dol==vn) {
6810 RemDosEntry(dol);
6811 break;
6812 }
6813 }
6814 // removevolumenode(dol, (struct DosList *)sfsm->data); /* Dangerous because of DOSBase?? */
6815 FreeDosEntry(vn);
6816 }
6817
6818 FreeVec(sfsm);
6819 }
6820
6821 UnLockDosList(LDF_WRITE|LDF_VOLUMES);
6822 }
6823 }
6824 else {
6825 Permit();
6826 }
6827 }
6828 else {
6829 Permit();
6830 }
6831
6832 CloseLibrary((struct Library *)DOSBase);
6833 }
6834 }
Mirror of AROS' svn.