| blob | 056568cfdc75385385437cb8ef8ca688ccc9c52c |
3 #include <exec/types.h>
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>
59 #include <string.h>
67 #define BNODE
69 #define BITMAPFILL 0xFFFFFFFF /* should be 0xFFFFFFFF ! Careful.. admin containers are 32 blocks! */
71 /* defines: */
77 /* Our own usage of NotifyRequest private data */
78 #define nr_Next nr_Reserved[2]
79 #define nr_Prev nr_Reserved[3]
81 /* structs */
82 #define SFSM_ADD_VOLUMENODE (1)
83 #define SFSM_REMOVE_VOLUMENODE (2)
87 ULONG command;
88 IPTR data;
89 LONG errorcode;
90 };
96 };
99 /* global variables */
103 #ifndef __AROS__
105 #endif
107 /* Prototypes */
114 /* Prototypes of cachebuffer related functions */
119 /* Prototypes of node related functions */
122 static LONG findextentbnode(ULONG key,struct CacheBuffer **returned_cb,struct fsExtentBNode **returned_bnode);
123 static LONG createextentbnode(ULONG key,struct CacheBuffer **returned_cb,struct fsExtentBNode **returned_bnode);
125 /* Prototypes of debug functions */
130 /* Misc prototypes */
151 #ifdef DEBUGCODE
153 #endif
161 /* Prototypes of high-level filesystem functions */
166 LONG seekextent(struct ExtFileLock *lock,ULONG offset,struct CacheBuffer **returned_cb,struct fsExtentBNode **returned_ebn,ULONG *returned_extentoffset);
176 /* ASM prototypes */
178 #define MAJOR_VERSION (1)
179 #define MINOR_VERSION (84)
181 #ifdef __GNUC__
183 #else
185 #endif
187 #ifdef __AROS__
188 /* AROS builds in a 'struct Resident' automatically
189 */
190 #else
191 /* ROMTag is useful for C:Version. */
192 #define res_Init NULL
195 {
196 RTC_MATCHWORD,
199 RTF_COLDSTART,
200 MAJOR_VERSION,
203 PROGRAMNAME,
205 res_Init
206 };
207 #endif
209 /* Main */
211 #ifndef __AROS__
216 #endif
220 #ifndef __AROS__
221 #undef SysBase
222 #endif
224 #ifndef __AROS__
226 {
230 }
233 {
235 /* if(STACKSWAP()==0) {
236 return(ERROR_NO_FREE_STORE);
237 }
239 return(mainprogram()); */
240 }
241 #endif
245 // #define STARTDEBUG
248 {
249 #ifndef __AROS__
250 ULONG reslen;
251 APTR old_a4;
252 APTR newdata;
253 #endif
258 #ifndef __AROS__
260 #endif
263 #ifndef __AROS__
264 #undef SysBase
265 #define SysBase (globals->sysBase)
275 #endif
296 #ifdef STARTDEBUG
298 #endif
302 /* Create a msgport and iorequest for opening timer.device */
307 if((globals->inactivitytimer_ioreq=(struct timerequest *)CreateIORequest(globals->msgporttimer, sizeof(struct timerequest)))!=0) {
308 if((globals->activitytimer_ioreq=(struct timerequest *)CreateIORequest(globals->msgportflushtimer, sizeof(struct timerequest)))!=0) {
310 #ifdef STARTDEBUG
312 #endif
321 /* Create a msgport and iorequest for opening the filesystem device */
325 #ifdef STARTDEBUG
327 #endif
329 if(initcachedio(AROS_BSTR_ADDR(globals->startupmsg->fssm_Device), globals->startupmsg->fssm_Unit, globals->startupmsg->fssm_Flags, globals->dosenvec)==0) {
330 #ifdef STARTDEBUG
332 #endif
337 globals->blocks_inbitmap=(globals->bytes_block-sizeof(struct fsBitmap))<<3; /* must be a multiple of 32 !! */
338 globals->blocks_bitmap=(globals->blocks_total+globals->blocks_inbitmap-1)/globals->blocks_inbitmap;
344 {
353 }
359 }
360 }
362 globals->block_rovingblockptr=globals->blocks_reserved_start + globals->blocks_admin + globals->blocks_bitmap + reserve;
366 // block_rovingblockptr=0;
367 }
379 #ifdef STARTDEBUG
381 #endif
385 #ifdef STARTDEBUG
387 #endif
389 /* return startup-packet, the handler runs now */
392 _DEBUG(("Mountlist entry says: Allocate %ld buffers of memtype 0x%08lx\n",globals->dosenvec->de_NumBuffers,globals->dosenvec->de_BufMemType));
394 // returnpacket(DOSTRUE,0); // Sep 19 1999: Moved down again.
399 {
404 };
412 }
415 #ifdef STARTDEBUG
417 #endif
420 }
422 #ifdef STARTDEBUG
424 #endif
427 }
431 #ifdef STARTDEBUG
433 #endif
436 }
437 }
440 }
444 }
446 }
448 }
450 }
452 }
454 }
456 }
458 }
460 }
462 #ifdef STARTDEBUG
464 #endif
467 }
468 }
475 }
481 }
485 ULONG signalbits;
495 #ifdef STARTDEBUG
497 #endif
508 }
512 /* There was another request during the timeout/2 period, so we extend the timeout a bit longer. */
515 }
520 }
521 }
525 }
529 /* The disk was inserted or removed! */
534 /* Disk was removed */
538 }
540 /* Disk was inserted */
543 }
544 }
549 // diskstate=writeprotection(); /* Don't do this too often!! It takes LOADS of time for scsi.device. */
552 #ifdef CHECKCODE_SLOW
553 {
567 }
570 }
571 }
572 #endif
577 #ifdef STARTDEBUG
579 #endif
583 {
594 }
599 }
604 }
606 }
607 }
610 }
613 {
618 {
620 {
626 /*
627 * Explicitly cast to ULONG here because on 64 bits
628 * ti_Data is 64-bit wide, and this can confuse programs.
629 */
707 }
708 }
711 }
715 {
719 }
723 {
724 LONG errorcode;
726 if((errorcode=setiocache(globals->packet->dp_Arg1, globals->packet->dp_Arg2, globals->packet->dp_Arg3 & 1))!=0) {
728 }
731 }
732 }
739 {
741 ULONG currentdate;
742 BLCK block_recycled;
773 }
774 }
775 }
779 }
781 /* Global block numbers */
789 /* Temporary block numbers */
797 }
804 /* Create AdminSpaceContainer block */
815 /* NOT HASHED RECYCLED
816 ac->adminspace[0].be_bits=L2BE(0xFF000000); // admin + root + hashtable + restore + 2 * nodecontainers + recycled + hash
817 */
818 ac->adminspace[0].be_bits=L2BE(0xFE000000); /* admin + root + hashtable + restore + 2 * nodecontainers + recycled */
819 }
821 ac->adminspace[0].be_bits=L2BE(0xFC000000); /* admin + root + hashtable + restore + 2 * nodecontainers */
822 }
826 }
830 struct fsRootInfo *ri=(struct fsRootInfo *)((UBYTE *)cb->data+globals->bytes_block-sizeof(struct fsRootInfo));
834 /* Create Root block */
850 }
854 ri->be_freeblocks=L2BE(globals->blocks_total-globals->blocks_admin-globals->blocks_reserved_start-globals->blocks_reserved_end-globals->blocks_bitmap);
859 }
866 /* Create Root's HashTable block */
877 }
881 }
888 /* Create empty block as a placeholder for the TransactionFailure block. */
898 }
906 /* Create NodeContainer block for ExtentNodes */
920 }
928 /* Create NodeContainer block for ObjectNodes */
942 on++;
946 }
949 }
951 on++;
954 on++;
957 on++;
960 on++;
965 }
983 }
987 /* NOT HASHED RECYCLED
988 oc->object[0].object.dir.hashtable=block_recycled+1;
989 */
996 }
998 /* NOT HASHED RECYCLED
999 if(errorcode==0 && norecycled==FALSE) {
1000 struct fsHashTable *ht=cb->data;
1002 _DEBUG(("ACTION_FORMAT: Creating Recycled's HashTable block\n"));
1004 cb->blckno=block_recycled+1;
1005 clearcachebuffer(cb);
1007 ht->bheader.id=HASHTABLE_ID;
1008 ht->bheader.ownblock=block_recycled+1;
1009 ht->parent=RECYCLEDNODE;
1011 setchecksum(cb);
1012 errorcode=writecachebuffer(cb);
1013 }
1014 */
1021 LONG sizefree;
1025 /* Create Bitmap blocks */
1043 }
1044 }
1049 }
1052 }
1053 }
1056 }
1057 }
1063 }
1064 }
1071 /* Create Root blocks */
1101 }
1104 }
1116 }
1117 }
1127 }
1130 }
1131 }
1137 /* This function nests. Each call to inhibit the disk should be matched
1138 with one to uninhibit the disk. */
1141 #ifdef STARTDEBUG
1143 #endif
1146 globals->disktype=ID_BUSY; /* Must be put before deinitdisk() Feb 27 1999: Maybe not needed anymore */
1148 }
1151 }
1155 during that time to this handler. As initdisk() needs to lock
1156 the doslist we MUST return the packet before calling initdisk() */
1158 }
1160 /* Workbench revokes ACTION_INHIBIT without ever actually having
1161 inhibited the volume. We'll just return the packet and ignore
1162 such requests. */
1165 }
1170 {
1172 LONG errorcode;
1176 struct fsRootInfo *ri=(struct fsRootInfo *)((UBYTE *)cb->data+globals->bytes_block-sizeof(struct fsRootInfo));
1183 }
1187 }
1190 }
1191 }
1202 {
1205 }
1206 /* else if(packet->dp_Arg4!=LINK_SOFT) {
1207 returnpacket(DOSFALSE,ERROR_BAD_NUMBER);
1211 LONG errorcode;
1216 _DEBUG(("ACTION_MAKE_LINK: Name = '%s', LinkPath = '%s'\n",globals->string,(UBYTE *)globals->packet->dp_Arg3));
1218 if((errorcode=findcreate(&lock,globals->string,globals->packet->dp_Type,(UBYTE *)globals->packet->dp_Arg3))!=0) {
1220 }
1222 // freelock(lock);
1224 }
1225 }
1226 }
1232 {
1237 LONG errorcode;
1238 NODE objectnode;
1244 }
1247 }
1258 }
1263 /* Move on to remainder of path after the link */
1268 }
1269 path++;
1270 }
1280 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)
1281 }
1285 _DEBUG(("ACTION_READ_LINK: length = %ld, sl->string = '%s', path = '%s'\n", length, sl->string, s));
1287 /* cb is no longer valid at this point. */
1289 /* Check if link target is an absolute path */
1294 }
1297 /* If target is a relative path, put path preceding
1298 link into buffer so that result is relative to
1299 lock passed in */
1304 }
1305 }
1307 /* Copy link target to buffer */
1310 }
1311 dest--;
1312 length++;
1314 /* Ensure we don't insert an extraneous slash */
1318 length++;
1319 }
1321 s++;
1322 }
1324 /* Append remainder of original path */
1327 }
1331 }
1332 }
1333 }
1334 }
1339 }
1342 }
1343 }
1347 }
1348 }
1353 {
1355 LONG errorcode;
1362 }
1365 }
1366 }
1375 {
1387 }
1392 }
1395 }
1396 }
1400 }
1408 }
1409 }
1410 }
1413 }
1414 }
1420 /* ACTION_FREE_LOCK's code is similair */
1422 {
1424 LONG errorcode;
1426 /* If a file has been modified by the use of ACTION_SET_FILE_SIZE or
1427 ACTION_WRITE, or ACTION_FINDOUTPUT or ACTION_FINDUPDATE (only when
1428 creating a new file) were used to create the file then we must
1429 also update the datestamp of the file. We also must send out a
1430 notification. Finally we also need to clear the A bit.
1432 For this purpose a special flag in the lock tells us
1433 whether or not any of the above actions has occured. */
1439 /* Aha! */
1445 }
1446 }
1456 }
1459 }
1460 }
1462 /* Ignore any errorcodes -- not really interesting when closing a file... */
1463 }
1467 }
1470 }
1471 }
1474 {
1475 LONG errorcode;
1479 _DEBUG(("ACTION_DELETE_OBJECT(0x%08lx,'%s')\n",BADDR(globals->packet->dp_Arg1),globals->string));
1484 if((errorcode=deleteobject(BADDR(globals->packet->dp_Arg1), validatepath(globals->string), TRUE))==0) {
1486 }
1489 }
1494 }
1501 }
1502 }
1505 }
1506 }
1511 {
1513 LONG errorcode;
1520 #ifndef USE_FAST_BSTR
1521 UBYTE len;
1522 #endif
1524 /* Succesfully locked the doslist */
1534 #if 0
1539 }
1543 }
1546 #endif
1550 #ifdef USE_FAST_BSTR
1552 #else
1557 }
1562 }
1564 #endif
1565 }
1571 }
1574 }
1575 }
1577 /* Doslist locking attempt was unsuccesful. Send this message back to our
1578 port to try it again later. */
1582 }
1583 }
1587 }
1590 }
1591 }
1596 {
1597 LONG errorcode;
1621 }
1624 }
1625 }
1628 }
1629 }
1636 }
1639 }
1640 }
1644 {
1645 LONG errorcode;
1652 if((errorcode=setcomment(BADDR(globals->packet->dp_Arg2),validatepath(globals->string),globals->string2))!=0) {
1654 }
1657 }
1662 }
1665 }
1666 }
1674 {
1675 LONG errorcode;
1696 checksum_writelong_be(cb->data, &o->be_datemodified, datestamptodate((struct DateStamp *)globals->packet->dp_Arg4));
1698 // o->datemodified=datestamptodate((struct DateStamp *)packet->dp_Arg4);
1699 }
1701 checksum_writelong_be(cb->data, &o->be_protection, globals->packet->dp_Arg4^(FIBF_READ|FIBF_WRITE|FIBF_EXECUTE|FIBF_DELETE));
1703 // o->protection=packet->dp_Arg4^(FIBF_READ|FIBF_WRITE|FIBF_EXECUTE|FIBF_DELETE);
1704 }
1706 // ULONG *owner=(ULONG *)&o->owneruid;
1710 // *owner=packet->dp_Arg4;
1711 }
1713 o->bits=(globals->packet->dp_Arg4 & (OTYPE_HIDDEN|OTYPE_UNDELETABLE)) | (o->bits & ~(OTYPE_HIDDEN|OTYPE_UNDELETABLE));
1715 }
1725 }
1726 }
1729 }
1730 }
1733 }
1734 }
1736 /* this 'loop' will only be left if the disk wasn't full, or
1737 cleanupdeletedfiles() couldn't free up any more space. */
1745 }
1748 }
1749 }
1752 _DEBUG(("ACTION_SET_FILE_SIZE(0x%08lx,0x%08lx,0x%08lx)\n",globals->packet->dp_Arg1,globals->packet->dp_Arg2,globals->packet->dp_Arg3));
1754 {
1756 LONG newfilesize;
1757 LONG errorcode;
1761 }
1764 }
1767 }
1771 }
1782 }
1783 }
1786 }
1790 }
1793 }
1794 }
1797 _XDEBUG((DEBUG_SEEK,"ACTION_SEEK(0x%08lx,0x%08lx,0x%08lx)\n",globals->packet->dp_Arg1,globals->packet->dp_Arg2,globals->packet->dp_Arg3));
1799 {
1803 LONG newpos;
1804 LONG errorcode;
1808 }
1811 }
1814 }
1818 }
1823 }
1826 }
1827 }
1830 }
1834 }
1837 }
1838 }
1841 _XDEBUG((DEBUG_IO,"ACTION_READ(0x%08lx,0x%08lx,%ld)\n",globals->packet->dp_Arg1,globals->packet->dp_Arg2,globals->packet->dp_Arg3));
1843 {
1847 ULONG bytesleft;
1849 LONG errorcode;
1854 }
1862 ULONG bytestoread;
1867 _XDEBUG((DEBUG_IO,"ACTION_READ: buffer = 0x%p bytesleft = %ld, offsetinblock = %ld, ExtentBNode = %ld, ebn->data = %ld, ebn->blocks = %ld\n",
1872 // _XDEBUG((DEBUG_IO,"ACTION_READ: nextextentbnode = %ld, extentnodesize = %ld, en->blocks = %ld\n",nextextentbnode,extentnodesize,(ULONG)ebn->blocks));
1876 /* Check if there are more bytes left in the block then we want to read */
1879 }
1881 if((errorcode=readbytes(BE2L(ebn->be_key)+(lock->extentoffset>>globals->shifts_block), buffer, offsetinblock, bytestoread))!=0) {
1883 }
1884 }
1889 /* Check if there are more bytes left in the Extent then we want to read */
1892 }
1894 if((errorcode=read(BE2L(ebn->be_key)+(lock->extentoffset>>globals->shifts_block), buffer, bytestoread>>globals->shifts_block))!=0) {
1896 }
1897 }
1905 }
1906 }
1909 }
1910 }
1912 _XDEBUG((DEBUG_IO,"ACTION_READ: errorcode = %ld, buffer = %ld, startofbuf = %ld\n",errorcode,buffer,startofbuf));
1916 }
1919 }
1920 }
1923 _XDEBUG((DEBUG_IO,"ACTION_WRITE(0x%08lx,0x%08lx,%ld)\n",globals->packet->dp_Arg1,globals->packet->dp_Arg2,globals->packet->dp_Arg3));
1925 {
1933 /* Save some values in case of an error: */
1946 }
1955 }
1956 }
1963 }
1969 }
1970 }
1975 {
1976 LONG errorcode;
1981 }
1983 }
1988 {
1995 ULONG eadsize;
1996 ULONG stringsize;
1997 LONG spaceleft;
1998 LONG errorcode;
2012 }
2017 }
2023 if((errorcode=readcachebuffercheck(&cb,BE2L(o->object.dir.be_firstdirblock),OBJECTCONTAINER_ID))==0) {
2028 }
2029 }
2032 }
2033 }
2036 }
2037 }
2038 }
2042 }
2043 }
2047 WORD keepentry;
2071 }
2073 // _DEBUG(("ACTION_EXAMINE_ALL: eadsize = %ld, stringsize = %ld, spaceleft = %ld, packet->dp_Arg4 = %ld\n",eadsize,stringsize,spaceleft,packet->dp_Arg4));
2077 }
2085 {
2093 eadsize++;
2094 }
2097 eadsize++;
2098 }
2106 }
2109 }
2114 }
2117 }
2120 }
2123 }
2125 {
2133 eadsize++;
2134 }
2137 eadsize++;
2139 // _DEBUG(("Stored entry %s\n",ead->ed_Name));
2140 }
2141 }
2145 }
2148 }
2152 #ifdef __AROS__
2154 #else
2155 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;
2157 #endif
2158 }
2165 }
2170 }
2172 {
2187 }
2188 }
2191 }
2192 }
2195 }
2196 }
2197 }
2201 }
2204 }
2205 }
2208 // _DEBUG(("ACTION_EXAMINE_NEXT(0x%08lx,0x%08lx)\n",BADDR(packet->dp_Arg1),BADDR(packet->dp_Arg2)));
2210 /* An entry is added to a directory in the first dir block with
2211 enough space to hold the entry. If there is no space, then
2212 a new block is added at the START of the directory, and the
2213 new entry is added there.
2215 In the directory block with enough space, the entry is added
2216 at the end of the block. The order of directory entries there
2217 fore is like this (square parenthesis indicate blocks):
2219 [789] [456] [123]
2221 This means we should scan the directory in the exact opposite
2222 order to avoid a trap when an entry is overwritten during
2223 directory scanning (MODE_NEW_FILE removes old entry, and adds
2224 a new one). See below:
2226 1. [123]; scan is at 1 (next = 2); 1 is overwritten.
2228 2. [231]; scan is at 2 (next = 3); 2 is overwritten.
2230 3. [312]; scan is at 3 (next = 1); 3 is overwritten.
2232 4. [123]; same as 1 -> loop!
2234 By scanning the internals of a dir block backwards the problem
2235 is solved:
2237 1. [123]; scan is at 3 (next = 2); 3 is overwritten.
2239 2. [123]; scan is at 2 (next = 1); 2 is overwritten.
2241 3. [132]; scan is at 1 (next = next block); 1 is overwritten.
2243 4. new block is loaded -> no loop. */
2245 {
2258 }
2260 /*
2261 if(lock->ocblck==0 && lock->ocnode==0) {
2262 _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"));
2264 returnpacket(DOSFALSE,ERROR_OBJECT_WRONG_TYPE);
2265 break;
2266 }
2267 */
2272 /* It looks like the lock was reallocated! In this case we must rebuild
2273 the state information in the lock. lock->currentnode, lock->nextnode
2274 and lock->nextnodeblock. */
2284 }
2288 }
2289 }
2290 }
2294 }
2296 /* The passed in lock describes a directory. EXAMINE_NEXT should return
2297 this directory's entries one at the time. The lock has state information
2298 which helps determine at which entry we currently are. */
2300 while(errorcode==0 && (errorcode=readcachebuffercheck(&cb, lock->nextnodeblock, OBJECTCONTAINER_ID))==0) {
2303 UBYTE bits;
2306 /*** It is possible findobject returns 0... */
2308 }
2312 }
2318 /* prepare for another EXAMINE_NEXT */
2320 /* We need to check if there is another object in this ObjectContainer
2321 following the one we just returned. If there is then return its
2322 node. If there isn't then return the next ObjectContainer ptr and
2323 set ocnode to zero. */
2326 /* There IS another object */
2328 }
2332 }
2336 }
2340 }
2341 }
2345 }
2348 }
2349 }
2351 #if 0
2352 /******** OLD EXAMINE_NEXT CODE! */
2354 // _DEBUG(("ACTION_EXAMINE_NEXT(0x%08lx,0x%08lx)\n",BADDR(packet->dp_Arg1),BADDR(packet->dp_Arg2)));
2356 /* An entry is added to a directory in the first dir block with
2357 enough space to hold the entry. If there is no space, then
2358 a new block is added at the START of the directory, and the
2359 new entry is added there.
2361 In the directory block with enough space, the entry is added
2362 at the end of the block. The order of directory entries there
2363 fore is like this (square parenthesis indicate blocks):
2365 [789] [456] [123]
2367 This means we should scan the directory in the exact opposite
2368 order to avoid a trap when an entry is overwritten during
2369 directory scanning (MODE_NEW_FILE removes old entry, and adds
2370 a new one). See below:
2372 1. [123]; scan is at 1 (next = 2); 1 is overwritten.
2374 2. [231]; scan is at 2 (next = 3); 2 is overwritten.
2376 3. [312]; scan is at 3 (next = 1); 3 is overwritten.
2378 4. [123]; same as 1 -> loop!
2380 By scanning the internals of a dir block backwards the problem
2381 is solved:
2383 1. [123]; scan is at 3 (next = 2); 3 is overwritten.
2385 2. [123]; scan is at 2 (next = 1); 2 is overwritten.
2387 3. [132]; scan is at 1 (next = next block); 1 is overwritten.
2389 4. new block is loaded -> no loop. */
2391 {
2404 }
2406 /*
2407 if(lock->ocblck==0 && lock->ocnode==0) {
2408 _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"));
2410 returnpacket(DOSFALSE,ERROR_OBJECT_WRONG_TYPE);
2411 break;
2412 }
2413 */
2418 /* It looks like the lock was reallocated! In this case we must rebuild
2419 the state information in the lock. lock->currentnode, lock->nextnode
2420 and lock->nextnodeblock. */
2432 }
2436 }
2437 }
2438 }
2442 }
2444 /* The passed in lock describes a directory. EXAMINE_NEXT should return
2445 this directory's entries one at the time. The lock has state information
2446 which helps determine at which entry we currently are. */
2448 while(errorcode==0 && (errorcode=readcachebuffercheck(&cb,lock->nextnodeblock,OBJECTCONTAINER_ID))==0) {
2451 UBYTE bits;
2454 /*** It is possible findobject returns 0... */
2456 }
2459 }
2465 /* prepare for another EXAMINE_NEXT */
2467 /* We need to check if there is another object in this ObjectContainer
2468 following the one we just returned. If there is then return its
2469 node. If there isn't then return the next ObjectContainer ptr and
2470 set ocnode to zero. */
2475 /* There IS another object */
2477 }
2481 }
2485 }
2489 }
2490 }
2494 }
2497 }
2498 }
2500 #endif
2506 {
2510 NODE objectnode;
2511 LONG errorcode;
2515 }
2518 }
2522 }
2525 }
2531 /* prepare for EXAMINE_NEXT */
2536 }
2539 }
2542 }
2543 }
2549 {
2558 }
2563 }
2568 {
2569 LONG errorcode;
2572 _DEBUG(("ACTION_MORE_CACHE: dp_Arg1 = %ld, totalbuffers = %ld, errorcode = %ld\n",globals->packet->dp_Arg1,globals->totalbuffers,errorcode));
2575 // returnpacket(DOSTRUE,totalbuffers);
2578 }
2581 }
2582 }
2585 {
2591 }
2594 }
2599 /* Convert shared lock into an exclusive lock. We need to check
2600 if there are no locks besides this one, and that we aren't
2601 trying to get an exclusive lock on the root (which is never
2602 allowed). */
2607 lock->objectnode=0; /* this makes sure that our lock is not taken into account by lockable() */
2610 /* Lockable says it is possible to lock it exclusively! */
2613 }
2616 }
2619 }
2622 }
2623 }
2625 /* Convert exclusive lock into a shared lock. Should always be
2626 possible. */
2629 }
2630 }
2631 }
2634 }
2638 }
2641 }
2642 }
2648 {
2649 LONG errorcode;
2654 }
2657 }
2662 }
2668 }
2671 }
2672 }
2678 {
2679 LONG errorcode;
2684 }
2687 }
2694 }
2697 }
2698 }
2701 {
2703 LONG errorcode;
2707 _XDEBUG((DEBUG_LOCK,"ACTION_LOCATE_OBJECT(0x%08lx,'%s',0x%08lx)\n",BADDR(globals->packet->dp_Arg1),globals->string,globals->packet->dp_Arg3));
2709 if((errorcode=lockobject((struct ExtFileLock *)BADDR(globals->packet->dp_Arg1),validatepath(globals->string),globals->packet->dp_Arg3,&lock))!=0) {
2711 }
2714 }
2715 }
2718 {
2722 LONG errorcode;
2726 }
2730 }
2733 }
2734 }
2737 {
2748 _DEBUG(("ACTION_ADD_NOTIFY: Starting notification on %s (flags 0x%08lx)\n",nr->nr_FullName,nr->nr_Flags));
2752 }
2755 }
2758 {
2766 /* Removing all outstanding messages form msgport */
2768 }
2770 }
2774 else
2784 }
2787 {
2788 LONG errorcode;
2792 }
2795 }
2796 }
2799 {
2800 LONG errorcode;
2805 errorcode=extractspace((UBYTE *)globals->packet->dp_Arg1, globals->packet->dp_Arg2, globals->packet->dp_Arg3);
2808 }
2811 {
2815 }
2818 {
2819 LONG errorcode;
2826 }
2828 while((errorcode=flushtransaction())!=0 && req("Pending buffers couldn't be flushed\nto the disk before defragmentation\nbecause of error %ld.", "Retry|Cancel", errorcode)==1) {
2829 }
2837 }
2841 while((errorcode=flushtransaction())!=0 && req("Pending buffers couldn't be flushed\nto the disk during defragmentation\nbecause of error %ld.", "Retry|Cancel", errorcode)==1) {
2842 }
2843 }
2844 }
2852 }
2854 }
2857 }
2860 }
2861 }
2867 }
2868 }
2871 }
2874 }
2875 }
2877 }
2878 }
2880 }
2881 }
2886 {
2889 UBYTE length;
2894 fib->fib_NumBlocks=(BE2L(o->object.file.be_size)+globals->bytes_block-1) >> globals->shifts_block;
2897 // fib->fib_DirEntryType=ST_USERDIR; // For compatibility with Diavolo 3.4 -> screw it, DOpus fails...
2900 }
2904 fib->fib_NumBlocks=(BE2L(o->object.file.be_size)+globals->bytes_block-1) >> globals->shifts_block;
2905 }
2910 }
2920 dest++;
2925 length++;
2926 }
2932 dest++;
2937 length++;
2938 }
2940 }
2950 }
2953 }
2954 }
2967 }
2989 }
2994 {
3014 }
3019 /* From the AbortIO AutoDocs:
3020 iORequest - pointer to an I/O request block (must have been used
3021 at least once. May be active or finished). */
3032 }
3035 }
3045 }
3046 }
3058 }
3060 // if(activitytimeractive!=FALSE) {
3061 // AbortIO(&activitytimer_ioreq->tr_node);
3062 // WaitIO(&activitytimer_ioreq->tr_node);
3063 //
3064 // activitytimeractive=FALSE;
3065 // }
3066 }
3071 LONG errorcode;
3073 /* Flushes any pending changes to disk and ask the user what to do when
3074 an error occurs. */
3076 while((errorcode=flushtransaction())!=0 && req("Pending buffers couldn't be flushed\nto the disk because of error %ld.", "Retry|Cancel", errorcode)==1) {
3077 }
3082 }
3088 /* Invalidates all caches without flushing. Call flushcaches()
3089 first. */
3093 }
3098 {
3106 LONG errorcode;
3110 }
3117 }
3124 if(checkchecksum(cb1)==DOSFALSE || rb1->bheader.id!=L2BE(DOSTYPE_ID) || rb1->bheader.be_ownblock!=0) {
3127 }
3129 _DEBUG(("checkchecksum(cb1)=%d, rb1->bheader.id=%08x (wanted %08x), rb1->bheader.ownblock=%d\n",
3131 ));
3133 if(checkchecksum(cb2)==DOSFALSE || rb2->bheader.id!=L2BE(DOSTYPE_ID) || BE2L(rb2->bheader.be_ownblock)!=BE2L(rb2->be_totalblocks)-1) {
3136 }
3138 _DEBUG(("checkchecksum(cb2)=%d, rb2->bheader.id=%08x, rb2->bheader.ownblock=%d, rb2->be_totalblocks =%d\n",
3139 checkchecksum(cb2),BE2L(rb2->bheader.id), BE2L(rb2->bheader.be_ownblock), BE2L(rb2->be_totalblocks)
3140 ));
3143 /* Both root blocks look okay. */
3145 /*
3146 if(rb1->sequencenumber!=rb2->sequencenumber) {
3147 // Sequence numbers differ!
3148 }
3149 */
3151 /* Check sizes stored in rootblock */
3152 if ((rb1->be_blocksize != L2BE(globals->bytes_block)) || (rb1->be_totalblocks!=L2BE(globals->blocks_total)))
3153 {
3156 }
3158 /*
3159 * Historically SFS rootblock holds absolute start and end positions on the disk in bytes.
3160 * They are used for validation and nothing else.
3161 * However, a situation is possible when for example someone takes an image of SFS partition
3162 * and then tries to mount it.
3163 * In order to make it working we compare lengths, not positions. If length is okay, the rootblock
3164 * is assumed to be okay.
3165 */
3170 {
3173 }
3176 /* Different version! */
3185 }
3195 }
3198 }
3202 }
3205 }
3206 }
3209 }
3212 }
3220 /* This function locates the specified volumenode, and if found
3221 uses it for the current volume inserted. If the node is not
3222 found this function returns 0. If the specified volumenode
3223 is found, but is found to be in use, then this function
3224 returns -1. Otherwise the found volumenode is returned. */
3229 if(datestamptodate(&dol->dol_misc.dol_volume.dol_VolumeDate)==creationdate) { // Do volumes have same creation date?
3231 if(dol->dol_misc.dol_volume.dol_LockList!=0 || ((struct DeviceList *)dol)->dl_unused!=0) { // Is volume not in use?
3235 /* Volume is not currently in use, so grab locklist & notifyrequests and patch fl_Task fields */
3252 }
3257 }
3261 }
3268 }
3269 }
3271 /* Volume nodes are of different date, continue search */
3273 }
3278 }
3284 /* This routine is called whenever a disk has changed (via ACTION_INHIBIT or
3285 on startup). The routine scans the disk and initializes the necessary
3286 variables. Steps:
3288 - Check if the disk is a valid DOS disk
3289 If so, get name and datestamp of the disk
3290 If valid, look for volume node of the same name and datestamp
3291 If so, retrieve locklist from dol_LockList (fix fl_Task fields!)
3292 and use existing volume node.
3293 If not, a new volume node is created.
3294 If the disk carries the same attributes as another ACTIVE volume
3295 the handler ignores the newly inserted volume.
3296 If not valid, R/W error requester -> "NDOS"
3297 If not valid type is "NDOS"
3299 */
3306 ULONG newdisktype;
3307 LONG errorcode;
3313 /* Root blocks are valid for this filesystem */
3317 #ifdef STARTDEBUG
3319 #endif
3326 struct fsRootInfo *ri=(struct fsRootInfo *)((UBYTE *)cb->data+globals->bytes_block-sizeof(struct fsRootInfo));
3334 /* ROOT block is valid for this filesystem */
3336 /* We should count the number of set bits in the bitmap now */
3338 {
3343 WORD n;
3352 }
3355 }
3356 }
3357 }
3358 bitmapblock++;
3359 }
3360 }
3371 }
3381 }
3384 }
3385 }
3392 #ifdef STARTDEBUG
3394 #endif
3395 }
3398 #ifdef STARTDEBUG
3400 #endif
3404 }
3405 }
3408 #ifdef STARTDEBUG
3410 #endif
3414 }
3415 }
3418 #ifdef STARTDEBUG
3420 #endif
3424 }
3425 }
3430 #ifdef STARTDEBUG
3432 #endif
3433 }
3435 #ifdef STARTDEBUG
3437 #endif
3441 }
3443 #ifdef STARTDEBUG
3445 #endif
3449 }
3451 #ifdef STARTDEBUG
3453 #endif
3457 }
3461 struct fsRootInfo *ri=(struct fsRootInfo *)((UBYTE *)oc+globals->bytes_block-sizeof(struct fsRootInfo));
3465 if((vn=usevolumenode(oc->object[0].name, BE2L(ri->be_datecreated)))!=(struct DeviceList *)-1) {
3467 /* VolumeNode was not found, so we need to create a new one. */
3474 #ifdef AROS_FAST_BSTR
3476 #else
3483 len++;
3484 }
3488 #endif
3500 }
3501 }
3504 }
3505 }
3513 }
3514 }
3517 newdisktype=ID_NO_DISK_PRESENT; /* Hmmm... EXTREMELY unlikely, but may explain the strange bug Laire had. */
3519 // vn=0;
3521 }
3522 }
3526 }
3531 }
3534 }
3535 }
3548 }
3552 }
3557 }
3558 }
3561 }
3562 }
3563 }
3571 }
3572 }
3573 }
3578 /* This function flushes all caches, and then invalidates them.
3579 If successful, this function then proceeds to either remove
3580 the volumenode, or transfer any outstanding locks/notifies to
3581 it. Finally it notifies the system of the disk removal. */
3590 /* We first check if the VolumeNode needs to be removed; if not
3591 then we do not lock the DosList and modify some of its fields.
3592 If it must be removed, we first attempt to lock the DosList
3593 synchronously; whether this fails or not, we always send a
3594 removal message to the DosList subtask. */
3598 /* There are locks or notifyrequests, so we cannot kill the volumenode. */
3600 /* We haven't got the DosList locked here, but I think it is fairly
3601 safe to modify these fields directly. */
3613 }
3623 }
3627 /* Even if we succesfully locked the DosList, we still should notify
3628 the DosList task to remove the node as well (and to free it), just
3629 in case a VolumeNode Add was still pending. */
3637 }
3638 }
3645 }
3646 }
3657 #ifndef __AROS__
3664 #endif
3676 }
3679 }
3686 /* Routine which returns ERROR_NOT_A_DOS_DISK for all known
3687 packets which cannot be handled under such a situation */
3725 #ifndef __AROS__
3727 #endif
3739 }
3742 }
3745 #ifdef DEBUGCODE
3749 /* routine which gets a packet and returns ERROR_NOT_A_DOS_DISK for all
3750 known packets which cannot be executed while we are attempting to access
3751 the doslist. Some packets which don't require disk access will be
3752 handled as normal. */
3758 }
3759 }
3760 #endif
3771 }
3774 }
3775 }
3789 }
3791 }
3803 }
3808 ULONG usedblocks;
3813 id->id_NumBlocks=globals->blocks_total-globals->blocks_reserved_start-globals->blocks_reserved_end;
3823 }
3824 }
3830 D(kprintf("Filling InfoData structure with a volumenode ptr to address %ld. Disktype = 0x%08lx\n", globals->volumenode, globals->disktype));
3834 _DEBUG(("fillinfodata: volumenode = %ld, disktype = 0x%08lx\n", globals->volumenode, globals->disktype));
3838 }
3841 }
3842 }
3847 #ifdef CHECKCHECKSUMSALWAYS
3849 #else
3850 if((cb->bits & CB_CHECKSUM)!=0 || CALCCHECKSUM(globals->bytes_block,cb->data)==0) { // -> copycachebuffer screws this up!
3851 #endif
3854 }
3856 }
3865 }
3870 LONG errorcode;
3887 }
3888 }
3890 /* if(request(PROGRAMNAME " request","%s\n"\
3891 "is not a DOS disk.",
3892 "Retry|Cancel",AROS_BSTR_ADDR(devnode->dn_Name),blckno,type,bh->id)<=0) {
3893 return(INTERR_BLOCK_WRONG_TYPE);
3894 } */
3897 }
3899 }
3909 }
3911 }
3921 "Reread|Cancel",AROS_BSTR_ADDR(globals->devnode->dn_Name),blckno,blckno,BE2L(bh->be_ownblock))<=0) {
3923 }
3925 }
3927 }
3929 }
3933 /* How the CacheBuffers work:
3934 ==========================
3936 When the filesystem starts, the number of buffers indicated
3937 by the Mountlist are allocated. If the number of buffers
3938 is below the minimum then the filesystem will increase the
3939 number of buffers to the minimum. AddBuffers can be used
3940 later to change the number of CacheBuffers.
3942 Each CacheBuffer is linked into two chains. An LRU chain,
3943 to quickly determine the least recently used CacheBuffer,
3944 and a Hash chain. The Hash chain is used to quickly locate
3945 a CacheBuffer which contains a specific block. Empty
3946 cachebuffers are not linked in the Hash chain and have a
3947 blckno of zero.
3949 After having read a few blocks there comes a time when you
3950 want to modify them. The CacheBuffer systems helps to make
3951 it simple to do safe updates to blocks without ever running
3952 the risk of leaving the disk in a state where links or
3953 pointers are not yet valid. If you want to modify a block
3954 or series of blocks you need to tell this to the caching
3955 system by calling newtransaction(). An operation is a series
3956 of modifications which, when written to disk completely,
3957 would result in a valid disk. By calling newtransaction() you
3958 signal that you are about to start a series of modifications
3959 which together will again result in a valid disk.
3961 If however at any point during an operation somekind of
3962 error occurs which prevents you from finishing the operation
3963 you should call deletetransaction(). This will remove all
3964 changes you made from the point when you called
3965 newtransaction() from the cache. These blocks will now never
3966 get written to disk, so there is no chance that the disk
3967 becomes invalid by partial modifications.
3969 This sums up how the caching mechanism works. The internal
3970 workings of routines like newtransaction() and
3971 deletetransaction() will be explained later on. One very
3972 important routine hasn't been mentioned here:
3973 flushtransaction(). This is the routine which actually makes
3974 modifications to the disk. It does this by flushing one
3975 operation at a time to disk (in old to new order of course)
3976 in such a way that even if the machine crashed in the middle
3977 of the flush that the disk would remain valid. After
3978 flushing all operations the cache is cleaned up.
3980 */
3985 /* Creating and moving objects
3987 1. Changing the comment on an object
3988 2. Changing the name of an object
3989 3. Creating a new object
3990 (4. Moving an object)
3992 Each of these three operations involves one or more of the following:
3994 1,2,3,4 - Locating enough new room for the object
3995 1,2,3,4 - Making sure the object-node points to the new block the
3996 object is located in.
3997 2 & 3 - Hashing the object
3998 3 - Allocating an ObjectNode.
4000 Order:
4002 'Allocating an ObjectNode' always precedes 'Hashing the Object' and 'Fixing the objectnode pointer'.
4003 'FindObjectSpace' always precedes 'Fixing the objectnode pointer'.
4005 1. FindObjectSpace OR Allocating an ObjectNode
4006 2. Fixing the objectnode pointer OR Hashing the Object */
4010 void fixlocks(struct GlobalHandle *gh,ULONG lastextentkey,ULONG lastextentoffset,ULONG filelength) {
4019 }
4021 /* Hmmm, this lock is positioned beyond the EOF... */
4025 }
4029 }
4031 }
4032 }
4034 }
4035 }
4040 BLCK lastextentbnode;
4041 LONG errorcode;
4043 /* This function extends the file identified by the lock with a number
4044 of blocks. Only new Extents will be created -- the size of the file
4045 will not be altered, and changing it is left up to the caller. If
4046 the file did not have any blocks yet, then lock->curextent will be
4047 set to the first (new) ExtentBNode. It's left up up to the caller
4048 to reflect this change in object.file.data.
4050 This function must be called from within a transaction. */
4052 _XDEBUG((DEBUG_IO,"extendblocksinfile: Increasing number of blocks by %ld. lock->curextent = %ld\n",blocks,lock->curextent));
4062 }
4063 }
4068 /* We found the last Extent. Now we should see if we can extend it
4069 or if we need to add a new one and attach it to this one. */
4073 BLCK searchstart;
4081 }
4083 }
4086 }
4091 }
4097 ULONG newspaceblocks;
4102 ULONG extentblocks;
4108 _XDEBUG((DEBUG_IO,"extendblocksinfile: sl->block = %ld, lastextentbnode = %ld, extentblocks = %ld\n",sl->block,lastextentbnode,extentblocks));
4113 }
4117 }
4121 _XDEBUG((DEBUG_IO,"extendblocksinfile: Done adding or extending an extent -- blocks = %ld, extentblocks = %ld\n",blocks,extentblocks));
4125 }
4126 sl++;
4127 }
4128 }
4129 }
4130 }
4133 }
4137 LONG truncateblocksinfile(struct ExtFileLock *lock,ULONG blocks,ULONG *lastextentkey,ULONG *lastextentoffset) {
4140 ULONG offset;
4141 ULONG extentoffset;
4142 LONG errorcode;
4144 /* Truncates the specified file to /blocks/ blocks. This function does not
4145 take care of setting the filesize. It also doesn't check for any locks
4146 which have a fileptr which is beyond the end of the file after calling
4147 this function. Its sole purpose is to reduce the number of blocks in
4148 the Extent list. */
4163 /* Darn. This Extent needs to be killed completely, meaning that we
4164 have to set the Next pointer of the previous Extent to zero. */
4178 }
4179 }
4195 }
4196 }
4197 }
4204 _DEBUG(("truncateblocksinfile: newblocks = %ld, ebn->blocks = %ld\n",newblocks,BE2W(ebn->be_blocks)));
4207 /* There is only one case where newblocks could equal en->blocks here,
4208 and that is if we tried to truncate the file to the same number of
4209 blocks the file already had! */
4222 errorcode=deleteextents(next); // Careful, deleting BNode's may change the location of other BNode's as well!
4223 }
4224 }
4227 }
4228 }
4229 }
4232 }
4240 /* This function sets the filesize of a file to /bytes/ bytes. If the
4241 file is not yet long enough, additional blocks are allocated and
4242 added to the file. If the file is too long the file will be shortened
4243 and the lost blocks are freed.
4245 Any filehandles using this file are set to the EOF if their current
4246 position would be beyond the new EOF when truncating the file.
4248 In any other case the position of the file ptr is not altered. */
4250 _DEBUG(("setfilesize: gh = 0x%08lx. Setting to %ld bytes. Current size is %ld bytes.\n",gh,bytes,gh->size));
4253 LONG blocksdiff;
4254 LONG curblocks;
4269 /* File (now) has right amount of blocks, only exact size in bytes may differ */
4277 }
4280 }
4281 }
4288 }
4289 }
4292 }
4293 }
4301 /* File needs to be shortened by -/blocksdiff/ blocks. */
4306 }
4308 _DEBUG(("setfilesize: lastextentkey = %ld, lastextentoffset = %ld\n",lastextentkey,lastextentoffset));
4314 /* File (now) has right amount of blocks, only exact size in bytes may differ */
4324 }
4325 }
4332 }
4335 }
4336 }
4340 }
4341 }
4344 }
4348 void seekforward(struct ExtFileLock *lock, UWORD ebn_blocks, BLCK ebn_next, ULONG bytestoseek) {
4350 /* This function does a simple forward seek. It assumes /bytestoseek/ is
4351 only large enough to skip within the current extent or to the very
4352 beginning of the next extent. */
4359 }
4360 }
4367 /* This function checks if the currentextent is still valid. If not,
4368 it will attempt to locate the currentextent. */
4372 /* lock->curextent==0 can indicate 2 things:
4374 - A previously empty file was extended by another handle; in this
4375 case the file-ptr (lock->offset) of this handle is still zero.
4377 - The extent has been moved by the defragmenter, and will have to
4378 be re-located. In this case the file-ptr doesn't have to be
4379 zero. */
4383 }
4387 ULONG extentoffset;
4392 }
4393 }
4394 }
4397 }
4403 ULONG extentoffset;
4404 LONG errorcode;
4406 /* This function moves the file-ptr to the specified absolute file
4407 position. It will return an error if you try to seek beyond the
4408 end of the file. */
4417 _XDEBUG((DEBUG_SEEK,"seek: lock->curextent = %ld, lock->extentoffset = %ld, lock->offset = %ld\n",lock->curextent,lock->extentoffset,lock->offset));
4418 }
4423 }
4432 /* Deletes an fsExtentBNode structure by key and any fsExtentBNodes linked to it.
4433 This function DOES NOT fix the next pointer in a possible fsExtentBNode which
4434 might have been pointing to the first BNode we are deleting. Make sure you check
4435 this yourself, if needed.
4437 If key is zero, than this function does nothing.
4439 newtransaction() should have been called prior to calling this function. */
4444 while(key!=0 && (errorcode=findbnode(globals->block_extentbnoderoot,key,&cb,(struct BNode **)&ebn))==0) {
4445 /* node to be deleted located. */
4447 // _XDEBUG((DDEBUG_NODES,"deleteextents: Now deleting key %ld. Next key is %ld\n",key,ebn->next));
4456 // _XDEBUG((DDEBUG_NODES,"deleteextents: deletebnode from root %ld, with key %ld\n",block_extentbnoderoot,ebn->key));
4458 if((errorcode=deletebnode(globals->block_extentbnoderoot,BE2L(ebn->be_key)))!=0) { /*** Maybe use deleteinternalnode here??? */
4460 }
4461 }
4465 }
4466 }
4468 // _XDEBUG((DEBUG_NODES,"deleteextents: Exiting with errorcode %ld\n",errorcode));
4471 }
4475 static LONG findextentbnode(ULONG key,struct CacheBuffer **returned_cb,struct fsExtentBNode **returned_bnode) {
4476 LONG errorcode;
4478 errorcode=findbnode(globals->block_extentbnoderoot,key,returned_cb,(struct BNode **)returned_bnode);
4480 #ifdef CHECKCODE_BNODES
4485 }
4486 #endif
4489 }
4492 /*
4493 LONG findobjectnode(NODE nodeno,struct CacheBuffer **returned_cb,struct fsObjectNode **returned_node) {
4494 return(findnode(block_objectnoderoot, sizeof(struct fsObjectNode), nodeno, returned_cb, (struct fsNode **)returned_node));
4495 }
4496 */
4499 static inline LONG createextentbnode(ULONG key,struct CacheBuffer **returned_cb,struct fsExtentBNode **returned_bnode) {
4500 return(createbnode(globals->block_extentbnoderoot,key,returned_cb,(struct BNode **)returned_bnode));
4501 }
4505 LONG seekextent(struct ExtFileLock *lock, ULONG offset, struct CacheBuffer **returned_cb, struct fsExtentBNode **returned_ebn, ULONG *returned_extentoffset) {
4506 BLCK extentbnode;
4509 /* When seeking there are 2 options; we start from the current extent,
4510 or we start from the first extent. Below we determine the best
4511 startpoint: */
4517 }
4519 // _DEBUG(("seekextent: offset = %ld, lock->offset = %ld, lock->extentoffset = %ld, lock->curextent = %ld\n",offset, lock->offset, lock->extentoffset, lock->curextent));
4524 }
4528 }
4530 /* Starting point has been determined. Let the seeking begin!
4531 We keep getting the next extent, until we find the extent which
4532 contains the required offset. */
4536 ULONG endbyte=*returned_extentoffset+(BE2W((*returned_ebn)->be_blocks)<<globals->shifts_block);
4539 /* Hooray! We found the correct extent. */
4541 }
4544 /* This break is here in case we run into the end of the file.
4545 This prevents *returned_extentoffset and extentbnode
4546 from being destroyed in the lines below, since it is still
4547 valid to seek to the EOF */
4550 /* There where no more blocks, but there should have been... */
4552 }
4554 }
4558 }
4559 }
4562 }
4566 /* Notify support functions. */
4574 /* Returns the full path of an object, or 0 if it fails. */
4583 }
4587 }
4592 }
4598 }
4599 }
4604 }
4613 /* /path/ doesn't have a trailing slash and start with a root directory (no colon) */
4620 }
4621 s1++;
4622 }
4626 // _DEBUG(("checknotify: path = '%s'\n", path));
4635 s2++;
4636 }
4638 /* "" == "hallo" -> no match
4639 "" == "/" -> match
4640 "" == "" -> match
4641 "/shit" == "" -> match (parent dir)
4642 "shit" == "" -> match (parent dir) */
4644 // _DEBUG(("checknotify: fullpath = '%s', nr->FullName = '%s'\n",s1,s2));
4646 if( (s1[0]==0 && (s2[0]==0 || (s2[0]=='/' && s2[1]==0))) || ((s2[0]==0 && (s1==lastslash || s1==lastslash+1)) && notifyparent==TRUE) ) {
4647 /* Wow, the string in the NotifyRequest matches! We need to notify someone! */
4649 _DEBUG(("checknotify: Notificating!! nr->FullName = %s, UserData = 0x%08lx\n",nr->nr_FullName, nr->nr_UserData));
4653 /* No else, if neither flag is set then do nothing. */
4654 }
4657 }
4658 }
4664 }
4670 /* This function sends a Notify to the client indicated by the passed
4671 in notifyrequest structure. */
4674 /* Sending them a signal. */
4679 }
4683 /* Sending them a message. */
4698 }
4699 }
4700 }
4707 #if 0
4714 }
4718 }
4734 /* At this point we can do 2 things with this cachebuffer. We can leave it
4735 hashed so if the user requests part of this block again it can quickly be grabbed
4736 from this CacheBuffer. The other option is the call emptycachebuffer()
4737 and let this buffer be reused ASAP. */
4740 }
4743 }
4744 }
4747 }
4748 #endif
4757 static LONG addblocks(UWORD blocks, BLCK newspace, NODE objectnode, BLCK *io_lastextentbnode) {
4760 LONG errorcode;
4762 /* This function adds /blocks/ blocks starting at block /newspace/ to a file
4763 identified by /objectnode/ and /lastextentbnode/. /io_lastextentbnode/ can
4764 be zero if there is no ExtentBNode chain attached to this file yet.
4766 This function must be called from within a transaction.
4768 /blocks/ ranges from 1 to 8192. To be able to extend Extents which are
4769 almost full, it is wise to make this value no higher than 8192 blocks.
4771 /io_lastextentbnode/ will contain the new lastextentbnode value when this
4772 function completes.
4774 This function makes no attempt to update any locks associated with this file,
4775 nor does it update the filesize information in a possible globalhandle.
4777 If there was no chain yet, then this function will create a new one. However
4778 it will NOT update object.file.data -- this is left up to the caller. */
4781 /* There was already a ExtentBNode chain for this file. Extending it. */
4790 /* It is possible to extent the last ExtentBNode! */
4797 }
4799 /* It isn't possible to extent the last ExtentBNode so we create
4800 a new one and link it to the last ExtentBNode. */
4804 if((errorcode=storecachebuffer(cb))==0 && (errorcode=createextentbnode(newspace,&cb,&ebn))==0) {
4819 }
4823 }
4824 }
4825 }
4826 }
4827 }
4828 }
4830 /* There is no ExtentBNode chain yet for this file. Attaching one! */
4847 }
4851 }
4852 }
4853 }
4854 }
4857 }
4888 }
4890 }
4892 }
4893 }
4897 #if 0
4899 () {
4906 /* File belonging to this lock was modified. */
4913 /* lastblock is now possibly the last block which is used by the file. This
4914 should always be true for newly created files which are being extended. */
4917 }
4918 }
4921 }
4922 }
4924 #endif
4930 /* This function tries to free up space. It does this by
4931 permanently deleting deleted files (if case of a recycled)
4932 and by flushing the current transaction if there is one.
4934 If no space could be freed, then this function returns
4935 FALSE. This is the go-ahead sign to report disk full
4936 to the user. */
4941 }
4945 }
4948 }
4954 LONG errorcode;
4956 /* This function must be called from within a transaction! */
4959 ULONG maxbytes;
4960 LONG newbytes;
4962 /* First thing we need to do is extend the file (if needed) to
4963 accomodate for all the data we are about to write. */
4965 maxbytes=(gh->size + globals->bytes_block-1) & ~globals->mask_block; // Maximum number of bytes file can hold with the current amount of blocks.
4966 newbytes=bytestowrite-(maxbytes-lock->offset); // Number of new bytes which would end up in newly allocated blocks.
4968 if((errorcode=seektocurrent(lock))==0 && (newbytes<=0 || (errorcode=extendblocksinfile(lock, (newbytes+globals->bytes_block-1)>>globals->shifts_block))==0)) {
4971 ULONG newfilesize;
4973 /* At this point, the file either didn't need extending, or was succesfully extended. */
4979 }
4981 /* If the filesize will change, then we set it below */
4996 }
4999 }
5000 }
5004 ULONG bytes;
5010 /* We are at the end +1 of this extent. Skip to next one. */
5015 }
5019 /** Partial writes to the last block of the file will cause a
5020 read of that block, even if this block didn't yet contain
5021 any valid data, because the file was just extended. This
5022 is unneeded... */
5024 /* File-ptr is located somewhere in the middle of a block, or at the
5025 start of the block but not at the end of the file. To add data
5026 to it we'll first need to read this block. */
5028 _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));
5034 }
5036 // if(newbytes>0 && offsetinblock==0) { /** offsetinblock check is NOT redundant. */
5037 // struct CacheBuffer *cb=getcachebuffer();
5038 //
5039 // CopyMem(buffer, cb->data, bytes);
5040 // errorcode=writethrough(lock->curextent + (lock->extentoffset>>shifts_block), cb->data, 1);
5041 // emptycachebuffer(cb);
5042 //
5043 // if(errorcode!=0) {
5044 // break;
5045 // }
5046 // }
5047 // else {
5048 if((errorcode=writebytes(BE2L(ebn->be_key)+(lock->extentoffset>>globals->shifts_block), buffer, offsetinblock, bytes))!=0) {
5050 }
5051 // }
5052 }
5059 /** This is a hack to speed up writes.
5061 What it does is write more bytes than there are in the buffer
5062 available (runaway writing), to avoid a seperate partial block
5063 write. It makes sure the extra data written doesn't extend
5064 into a new 4K page (assuming MMU is using 4K pages). */
5066 // #define MMU_PAGESIZE (524288)
5067 //
5068 // if(((ULONG)(buffer+bytes) & ~(MMU_PAGESIZE-1))==((ULONG)(buffer+bytes+bytes_block-1) & ~(MMU_PAGESIZE-1))) {
5069 // bytes=bytestowrite;
5070 // }
5071 }
5073 // _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));
5075 if((errorcode=write(BE2L(ebn->be_key)+(lock->extentoffset>>globals->shifts_block), buffer, (bytes+globals->bytes_block-1)>>globals->shifts_block))!=0) {
5077 }
5078 }
5084 }
5085 }
5086 }
5087 }
5090 }
5093 }
5102 /* cbobject & o refer to the file to be deleted (don't use this for objects
5103 other than files!). The file is deleted a piece at the time. This is
5104 because then even in low space situations files can be deleted.
5106 Note: This function deletes an object without first checking if
5107 this is allowed. Use deleteobject() instead. */
5111 /* First we search for the last ExtentBNode */
5121 while((errorcode=findbnode(globals->block_extentbnoderoot,key,&cb,(struct BNode **)&ebn))==0) {
5127 }
5129 }
5131 /* Key could be zero (in theory) or contains the last ExtentBNode for this file. */
5146 if((errorcode=findbnode(globals->block_extentbnoderoot, key, &cb, (struct BNode **)&ebn))==0) {
5155 }
5156 }
5163 // o->object.file.data=0;
5164 // o->object.file.size=0;
5168 }
5169 }
5170 }
5171 }
5174 }
5177 /* Unlocked CacheBuffers could be killed after an endtransaction()! */
5179 }
5183 }
5184 }
5185 }
5188 }
5194 /* File-data was succesfully freed. Now remove the empty object. */
5201 }
5204 }
5209 }
5212 /*
5214 Transactions
5215 ------------
5217 ReadCacheBuffer
5218 ReadOriginalCacheBuffer
5219 LockCacheBuffer
5220 UnLockCacheBuffer
5221 NewTransaction
5222 DeleteTransaction
5223 EndTransaction
5224 StoreCacheBuffer
5225 PrepareCacheBuffer
5227 The transaction system allows the filesystem to keep track
5228 of changes made to blocks in the cache. Every change is
5229 stored in a transaction buffer. The transaction buffer and
5230 the original version of a block can be used to restore the
5231 latest version of a block at any time.
5233 At any time you can use readcachebuffer() to get the latest
5234 version of a block. This could be a partially modified
5235 version if you're in the middle of a transaction, the latest
5236 version stored in the transaction buffer or the original
5237 version from disk.
5239 When you want to make changes to a block you call
5240 preparecachebuffer(). This checks if the block you're
5241 preparing to change is the original version, and if so makes
5242 a backup copy. This copy is not strictly needed, but it
5243 speeds up the filesystem to keep the original version around
5244 in case we need it later. The preparecachebuffer() function
5245 also calls lockcachebuffer() so the block you're changing
5246 won't be reused in subsequent cache operations.
5248 When you're satisfied with the changes you've made to a
5249 specific block you should call storecachebuffer(). This
5250 stores the changes into the transaction buffer. From that
5251 point on readcachebuffer() will be able to recreate the
5252 block with your new modifications.
5254 Before calling preparecachebuffer() for the first time, you
5255 need to call newtransaction(). This is to let the
5256 transaction system know you're about to start a new series
5257 of modifications.
5259 When you're done making all the changes to multiple blocks
5260 you need to call endtransaction(). This makes all the
5261 changes permanent. If there was an error along the way you
5262 can call deletetransaction() and all the changes you stored
5263 with storecachebuffer() since you're last call to
5264 newtransaction() will automatically be discarded.
5266 Any cachebuffers you had locked at the time which had
5267 changes in them will be restored to their original state (in
5268 reality these buffers will simply be reread using
5269 readcachebuffer()).
5271 Examples:
5273 x=readcachebuffer(0); // x.data = 1
5275 newtransaction();
5277 preparecachebuffer(x);
5279 x.data=2;
5281 storecachebuffer(cb);
5283 deletetransaction(); // x.data = 1;
5285 read(x) -> "AA"; newtr(); prep(x); write("CC") -> "CC"; store(x); endtr() -> "CC";
5287 read(x) -> "AA"; newtr(); prep(x); write("CC") -> "CC"; store(x); deltr() -> "AA";
5289 read(x) -> "AA"; newtr(); prep(x); write("CC") -> "CC"; store(x); newtr(); prep(x); write("EE") -> "EE"; store(x); deltr() -> "CC"; deltr() -> "AA";
5291 */
5302 /* This function set the previous value of the
5303 passed Extent. If the passed Extent is zero
5304 then this function does nothing. */
5312 }
5315 }
5322 LONG errorcode;
5324 /* This function sets the next value of the
5325 passed Extent/Object to key. */
5333 }
5343 }
5344 }
5347 }
5354 LONG errorcode;
5356 /* This function tries to merge the current extent with the
5357 next extent. If the extent can't be merged, or was
5358 succesfully merged then this function returns 0. Any
5359 error which occured during merging will be returned. */
5363 /* We check if we found the right key, if there is a next Extent and
5364 if the two Extents touch each other: */
5366 if(BE2L(ebn->be_key)==key && BE2L(ebn->be_next)!=0 && BE2L(ebn->be_key)+BE2W(ebn->be_blocks) == BE2L(ebn->be_next)) {
5370 if((errorcode=findextentbnode(BE2L(ebn->be_next), &cb2, &ebn2))==0 && BE2W(ebn2->be_blocks)+BE2W(ebn->be_blocks) < 65536) {
5373 /* Merge next extent with our extent */
5380 if((errorcode=storecachebuffer(cb))==0) { // call storecachebuffer() here, because deletebnode() may move our BNode.
5382 if((errorcode=deletebnode(globals->block_extentbnoderoot, BE2L(ebn2->be_key)))==0) { /*** Maybe use deleteinternalnode here??? */
5384 }
5385 }
5386 }
5387 }
5388 }
5391 }
5398 LONG errorcode;
5400 /* This function creates a new extent, but won't create one if it can
5401 achieve the same effect by extending the next or previous extent.
5402 In the unlikely case that the new extent is located EXACTLY between
5403 its predecessor and successor then an attempt will be made to merge
5404 these 3 extents into 1. */
5406 /*
5407 prev available & mergeable -> merge.
5408 prev available, but not mergeable -> create new -> update next -> update previous.
5409 prev not available -> create new -> update next -> update object
5410 */
5414 if((prev & 0x80000000)==0 && prev+BE2W(ebn->be_blocks) == key && BE2W(ebn->be_blocks)+blocks < 65536) {
5416 /* Extent we are inserting is mergeable with its previous extent. */
5420 ebn->be_blocks=W2BE(BE2W(ebn->be_blocks)+blocks); /* This merges the previous and the new extent */
5424 }
5425 }
5428 /* Extent we are inserting couldn't be merged with its previous extent. */
5430 if((errorcode=setprevextent(prev, key))==0 && (errorcode=createextentbnode(key, &cb, &ebn))==0) {
5432 /* Succesfully updated previous extent, or the object. Also created new BNode */
5442 }
5443 }
5444 }
5445 }
5446 }
5449 }
5458 /* Truncates the extended by the given amount of blocks.
5459 If the amount is negative then the truncation occurs
5460 at the start, otherwise at the end.
5462 This function returns INTERR_EXTENT if you tried to
5463 truncate to zero blocks (or beyond). Any errorcode
5464 is returned. If blocks is zero, then this function
5465 does nothing.
5467 Mar 20 1999: The truncation at the start could cause
5468 BNode's to get lost (because they are
5469 indexed by their start block). Fixed. */
5473 ULONG b;
5483 /* Truncating at the start. */
5489 if((errorcode=createbnode(globals->block_extentbnoderoot, key, &cb, (struct BNode **)&ebn))==0) {
5496 /* Truncating at start means changing the key value. This
5497 means that the next and previous BNode's must also be
5498 adjusted. */
5502 }
5503 }
5504 }
5505 }
5506 }
5509 /* Truncating at the end. */
5516 }
5517 }
5520 }
5521 }
5522 }
5525 }
5530 ULONG blocks;
5533 /* Low-level function to copy blocks from one place to another. */
5539 }
5543 }
5547 }
5552 }
5555 }
5561 LONG errorcode;
5563 /* Deletes an fsExtentBNode structure and properly relinks the rest of the chain.
5564 No space will be given free.
5566 newtransaction() should have been called prior to calling this function. */
5571 if((errorcode=deletebnode(globals->block_extentbnoderoot,BE2L(ebn->be_key)))==0) { /*** Maybe use deleteinternalnode here??? */
5574 }
5575 }
5578 }
5585 }
5587 }
5599 }
5600 }
5609 }
5610 }
5616 LONG errorcode;
5618 /* This function (partially) moves the Extent to /dest/.
5619 /blocks/ is the number of blocks moved; if blocks is
5620 equal to the size of the Extent, then the Extent will
5621 be deleted. Else the start of the Extent will be
5622 truncated. */
5630 if((errorcode=copy(key, dest, blocks, buf))==0) { // This functions knows that OPTBUFSIZE is the size of the buffer!
5632 /* Data has been physically moved -- nothing has been
5633 permanently altered yet. */
5639 /* Bitmap has been altered to reflect the new location of the
5640 moved data. Now we either need to truncate the Extent (if
5641 it was partially moved) or remove it. */
5648 }
5649 }
5653 }
5658 }
5659 }
5660 }
5661 }
5662 }
5665 }
5668 }
5671 }
5678 LONG errorcode;
5680 /* This function will attempt to fill the gap behind an extent with
5681 data from the next extent. This in effect merges the extent and
5682 the next extent (partially). */
5691 LONG free;
5701 /* The gap consists of /free/ blocks. */
5705 }
5708 }
5712 }
5715 }
5718 }
5719 }
5720 }
5725 }
5729 LONG getbnode(BLCK block, struct CacheBuffer **returned_cb, struct fsExtentBNode **returned_ebn) {
5730 LONG errorcode;
5732 /* This function gets the ExtentBNode which starts at the given
5733 block or the first one after the given block. Zero *ebn indicates
5734 there were no ExtentBNode's at or after the given block. */
5736 if((errorcode=findbnode(globals->block_extentbnoderoot, block, returned_cb, (struct BNode **)returned_ebn))==0) {
5738 _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)));
5741 errorcode=nextbnode(globals->block_extentbnoderoot, returned_cb, (struct BNode **)returned_ebn);
5743 _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)));
5744 }
5745 }
5748 }
5752 #if 0
5756 LONG errorcode;
5758 /* This function tries to move the data located at /block/ to
5759 another area of the disk. */
5762 ULONG blocks;
5763 ULONG newblocks;
5764 BLCK startblock;
5770 if((errorcode=findspace2_backwards(blocks, block, blocks_total, &startblock, &newblocks))==0) {
5775 _DEBUG(("makefreespace: Looking for %ld blocks from block %ld, and found %ld blocks at block %ld.\n", blocks, block, newblocks, startblock));
5778 }
5781 }
5782 }
5785 }
5786 }
5789 }
5790 #endif
5796 LONG errorcode;
5799 /* This function tries to move the data located at /block/ to
5800 another area of the disk. */
5804 ULONG blocks;
5805 ULONG newblocks;
5806 BLCK startblock;
5812 if((errorcode=findspace2_backwards(blocks, BE2L(ebn->be_key), globals->blocks_total, &startblock, &newblocks))==0) { // ebn->key should not be changed to block.
5817 _DEBUG(("makefreespace: Looking for %ld blocks from block %ld, and found %ld blocks at block %ld.\n", blocks, block, newblocks, startblock));
5821 }
5822 }
5826 }
5828 }
5829 }
5833 }
5837 }
5841 }
5844 }
5847 }
5855 /* This function looks for moveable data or free space starting
5856 from the given block. It returns -1 in case of failure, or
5857 the first moveable block it finds. If there ain't no more
5858 moveable blocks, then blocks_total is returned. */
5863 }
5864 else if(ebn==0 || BE2L(ebn->be_key)>=block || nextbnode(globals->block_extentbnoderoot, &cb, (struct BNode **)&ebn)==0) {
5867 LONG used;
5869 /* Found something moveable, but maybe there was some free space before the
5870 moveable Extent. */
5875 }
5878 }
5879 }
5880 }
5882 LONG errorcode;
5886 }
5889 }
5890 }
5891 }
5892 }
5895 }
5902 while((BE2L(ebn->be_prev) & 0x80000000)==0 && (errorcode=findextentbnode(BE2L(ebn->be_prev), &cb, &ebn))==0) {
5903 }
5907 }
5910 }
5914 #if 0
5918 // struct fsExtentBNode *ebn_start;
5920 LONG errorcode;
5922 /* This function looks for the start of a ExtentBNode chain
5923 which matches the given size. If none is found, then the
5924 next smaller chain is returned. If none is found, then a
5925 larger chain is returned. If there are no chains at all
5926 0 is returned.
5928 The first ExtentBNode examined is determined by the start
5929 block number which is passed. */
5931 _DEBUG(("findmatch: Looking for a chain of %ld blocks starting from block %ld\n", blocks, startblock));
5943 ULONG total=ebn->blocks; /* If larger than bestblocks, then we can stop looking for the start of the ExtentBNode chain early. */
5947 // ebn_start=startofextentbnodechain(ebn);
5948 {
5951 while((total<bestblocks || bestblocks==0) && (ebn_start->prev & 0x80000000)==0 && ebn_start->prev >= ebn->key && (errorcode=findextentbnode(ebn_start->prev, &cb, &ebn_start))==0) {
5953 }
5954 }
5959 }
5973 }
5982 }
5987 }
5988 }
5992 }
5993 }
5995 } while((errorcode=nextbnode(block_extentbnoderoot, &cb, (struct BNode **)&ebn))==0 && ebn!=0);
5996 }
5999 }
6000 #endif
6009 }
6016 }
6021 }
6022 }
6026 }
6029 }
6033 #if 0
6038 }
6043 }
6044 }
6048 }
6049 }
6052 }
6053 #endif
6058 }
6071 }
6072 }
6078 /*
6079 void newfragmentinit_small(ULONG blocks) {
6080 ULONG *f=fragment;
6081 UBYTE *fb=fragmenttype;
6082 WORD n=FRAGMENTS;
6084 newfragmentinit_large(blocks);
6086 while(--n>=0) {
6087 *f++=0;
6088 *fb++=0;
6089 }
6090 }
6094 ULONG newfragment_small(ULONG block, ULONG blocks, UBYTE type) {
6095 if(blocks<searchedblocks) {
6096 if(fragment[blocks]==0 || (fragmenttype[blocks]!=0 && type==0)) {
6097 ULONG blocks2=searchedblocks-blocks;
6099 fragment[blocks]=block;
6100 fragmenttype[blocks]=type;
6102 if(blocks2==blocks) {
6103 blocks2=0;
6104 }
6106 if(fragment[blocks2]!=0) {
6107 if(fragmenttype[blocks]==0 && fragmenttype[blocks2]==0) {
6108 return(fragment[blocks]);
6109 }
6110 }
6111 }
6112 }
6114 return(newfragment_large(block, blocks, type));
6115 }
6116 */
6128 }
6132 }
6133 }
6136 }
6142 }
6147 #if 0
6153 LONG errorcode;
6155 /* This function looks for the start of a ExtentBNode chain
6156 which matches the given size. If none is found, then the
6157 next smaller chain is returned. If none is found, then a
6158 larger chain is returned. If there are no chains at all
6159 0 is returned.
6161 The first ExtentBNode examined is determined by the start
6162 block number which is passed. */
6164 _DEBUG(("findmatch: Looking for a chain of %ld blocks starting from block %ld\n", blocks, startblock));
6170 }
6173 }
6183 ULONG newblocks;
6184 UBYTE fragmenttype;
6186 /* Found the start of a candidate chain. */
6194 }
6202 }
6205 }
6209 }
6213 }
6216 }
6217 } while((errorcode=nextbnode(block_extentbnoderoot, &cb, (struct BNode **)&ebn))==0 && ebn!=0);
6222 }
6225 }
6226 }
6227 }
6230 }
6231 #endif
6239 LONG errorcode;
6241 /* This function looks for the start of a ExtentBNode chain
6242 which matches the given size. If none is found, then the
6243 next smaller chain is returned. If none is found, then a
6244 larger chain is returned. If there are no chains at all
6245 0 is returned.
6247 The first ExtentBNode examined is determined by the start
6248 block number which is passed. */
6250 _DEBUG(("findmatch_fromend: Looking for a chain of %ld blocks starting from block %ld\n", blocks, startblock));
6256 }
6259 }
6261 if((errorcode=lastbnode(globals->block_extentbnoderoot, &cb, (struct BNode **)&ebn))==0 && ebn!=0 && BE2L(ebn->be_key)>=startblock) {
6263 _DEBUG(("findmatch_fromend: ebn->key = %ld, ebn->blocks = %ld\n", BE2L(ebn->be_key), BE2W(ebn->be_blocks)));
6269 ULONG newblocks;
6271 _DEBUG(("findmatch_fromend!: ebn->key = %ld, ebn->blocks = %ld\n", BE2L(ebn->be_key), BE2W(ebn->be_blocks)));
6273 /* Found the start of a candidate chain. */
6281 }
6287 }
6290 }
6294 }
6298 }
6299 }
6300 } while((errorcode=previousbnode(globals->block_extentbnoderoot, &cb, (struct BNode **)&ebn))==0 && ebn!=0 && BE2L(ebn->be_key)>=startblock);
6305 }
6308 }
6309 }
6312 }
6313 }
6316 }
6321 LONG errorcode;
6322 LONG free;
6326 _DEBUG(("Defragmenter: Found %ld blocks of free space at block %ld.\n", free, globals->block_defragptr));
6332 /* Determine in which extent block_defragptr is located. */
6334 if((errorcode=findbnode(globals->block_extentbnoderoot, globals->block_defragptr, &cb, (struct BNode **)&ebn))==0) {
6336 LONG block;
6340 /* Skip unmoveable data */
6344 }
6347 }
6348 }
6351 _DEBUG(("Defragmenter: Found a (partially) defragmented extent at block %ld.\n", globals->block_defragptr));
6354 /* If there is no next Extent, or if the next Extent is touching
6355 this one, then skip the current one. */
6360 }
6362 LONG freeafter;
6371 _DEBUG(("Defragmenter: There are %ld blocks of free space after the extent at block %ld.\n", freeafter, key));
6374 /* Move (part of) data located in next extent to this free space. */
6378 /* The function below can be called multiple times in a row. When there is a large
6379 gap in which multiple extents of the file will fit, then these can all be transfered
6380 into the gap at once. */
6383 }
6385 LONG block;
6387 /* Determine which extent it is which is located directly after the current extent. */
6394 /* There was no unmoveable data, so let's move it. */
6397 }
6399 LONG freeafter;
6403 /* Unmoveable data was skipped. */
6405 if(block!=next) { // Mar 20 1999: Check to see if the extent after the unmoveable data is not already the correct one.
6409 _DEBUG(("Defragmenter: There are %ld blocks of free space after the unmoveable data.\n", freeafter));
6418 }
6420 _DEBUG(("Defragmenter: There are now %ld blocks of cleared space after the unmoveable data.\n", freeafter));
6421 }
6422 }
6430 _DEBUG(("Defragmenter: Moved next extent of our extent directly after the unmoveable space (block = %ld).\n", block));
6434 }
6435 }
6436 }
6437 }
6440 }
6441 }
6444 /* Extent after unmoveable data is already correct, so no need to move it. */
6447 }
6448 }
6449 }
6452 }
6453 }
6454 }
6457 }
6458 }
6459 }
6462 _DEBUG(("Defragmenter: Found an extent at block %ld which must be moved away.\n", globals->block_defragptr));
6465 }
6466 }
6467 }
6469 ULONG bestkey;
6481 }
6482 }
6487 }
6488 }
6489 }
6490 }
6493 }
6498 }
6502 /*
6504 if (block at block_optimizeptr is full) {
6506 determine in which extent block_optimizeptr is located.
6508 if (not located in extent) {
6509 skip unmoveable data: add 1 to block_optimizeptr.
6510 }
6511 else if (extent is first extent OR previous extent is located before block_optimizeptr) {
6512 if (extent is last extent (as well)) {
6513 file was defragmented: set block_optimizeptr to point just after this extent.
6514 }
6515 else {
6516 determine if there is free space located after this extent.
6518 if (there is free space) {
6519 move (part of) data located in next extent to this free space.
6520 }
6521 else {
6523 determine which extent it is which is located directly after the current extent.
6525 if (no such extent exists) {
6526 skip unmoveable data
6528 if (no free space after unmoveable data) {
6529 make some free space by moving data.
6530 }
6531 move (part of) data located in next extent to the (newly made) free space: set block_optimizeptr in this part.
6532 }
6533 else {
6534 make some free space first by moving data.
6535 }
6536 }
6537 }
6538 }
6539 else {
6540 make some free space by moving data at block_optimizeptr.
6541 }
6542 }
6543 else {
6545 determine amount of free space.
6547 look for an extent-chain equal to the amount of free space beyond this location.
6549 if (found suitable extent-chain) {
6550 move data to block_optimizeptr; set block_optimizeptr to point just after this data.
6551 }
6552 else {
6553 scan for ANY 'first' extent beyond this location.
6555 if (none found) {
6556 optimization is done.
6557 }
6558 else {
6559 move found 'first' extent to block_optimizeptr.
6560 }
6561 }
6562 }
6565 */
6568 /* The simple purpose of the SFS DosList handler task is to
6569 provide the following non-blocking functions:
6571 - Adding a VolumeNode to the DosList
6572 data = VolumeNode
6574 - Removing a VolumeNode from the DosList (synchronously)
6575 data = VolumeNode
6577 All messages sent to the DosList handler are freed by
6578 the DosList handler itself. This is to avoid having to
6579 wait for the reply and then free the message yourself.
6580 */
6582 #ifdef __AROS__
6583 #undef globals
6584 #else
6585 #undef SysBase
6586 #endif
6587 #undef DOSBase
6590 {
6591 #ifndef __AROS__
6593 #endif
6618 /* AddDosEntry rejects volumes based on their name and date. */
6622 }
6624 // if(AddDosEntry((struct DosList *)sfsm->data)==DOSFALSE) {
6625 // errorcode=IoErr();
6626 // FreeDosEntry((struct DosList *)vn);
6627 // vn=0;
6628 // }
6629 }
6637 }
6638 }
6639 // removevolumenode(dol, (struct DosList *)sfsm->data); /* Dangerous because of DOSBase?? */
6641 }
6644 }
6647 }
6648 }
6651 }
6652 }
6655 }
6658 }
6659 }