![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pcfs_fat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / pcfs|
Return to pcfs_fat.c CVS log | Up to [Net/2] / Net2 / pcfs |
1.1 ! root 1: /* ! 2: * Written by Paul Popelka ([email protected]) ! 3: * ! 4: * You can do anything you want with this software, ! 5: * just don't say you wrote it, ! 6: * and don't remove this notice. ! 7: * ! 8: * This software is provided "as is". ! 9: * ! 10: * The author supplies this software to be publicly ! 11: * redistributed on the understanding that the author ! 12: * is not responsible for the correct functioning of ! 13: * this software in any circumstances and is not liable ! 14: * for any damages caused by this software. ! 15: * ! 16: * October 1992 ! 17: * ! 18: * pcfs_fat.c,v 1.3 1993/05/20 03:34:12 cgd Exp ! 19: */ ! 20: ! 21: /* ! 22: * kernel include files. ! 23: */ ! 24: #include "param.h" ! 25: #include "systm.h" ! 26: #include "buf.h" ! 27: #include "file.h" ! 28: #include "namei.h" ! 29: #include "mount.h" /* to define statfs structure */ ! 30: #include "vnode.h" /* to define vattr structure */ ! 31: #include "errno.h" ! 32: ! 33: /* ! 34: * pcfs include files. ! 35: */ ! 36: #include "bpb.h" ! 37: #include "pcfsmount.h" ! 38: #include "direntry.h" ! 39: #include "denode.h" ! 40: #include "fat.h" ! 41: ! 42: /* ! 43: * Fat cache stats. ! 44: */ ! 45: int fc_fileextends; /* # of file extends */ ! 46: int fc_lfcempty; /* # of time last file cluster cache entry ! 47: * was empty */ ! 48: int fc_bmapcalls; /* # of times pcbmap was called */ ! 49: #define LMMAX 20 ! 50: int fc_lmdistance[LMMAX]; /* counters for how far off the last cluster ! 51: * mapped entry was. */ ! 52: int fc_largedistance; /* off by more than LMMAX */ ! 53: ! 54: /* Byte offset in FAT on filesystem pmp, cluster cn */ ! 55: #define FATOFS(pmp, cn) (FAT12(pmp) ? (cn) * 3 / 2 : (cn) * 2) ! 56: ! 57: ! 58: static void fatblock (pmp, ofs, bnp, sizep, bop) ! 59: struct pcfsmount *pmp; ! 60: u_long ofs; ! 61: u_long *bnp; ! 62: u_long *sizep; ! 63: u_long *bop; ! 64: { ! 65: u_long bn, size; ! 66: ! 67: bn = ofs / pmp->pm_fatblocksize * pmp->pm_fatblocksec; ! 68: size = min (pmp->pm_fatblocksec, pmp->pm_FATsecs - bn) ! 69: * pmp->pm_BytesPerSec; ! 70: bn += pmp->pm_fatblk; ! 71: if (bnp) ! 72: *bnp = bn; ! 73: if (sizep) ! 74: *sizep = size; ! 75: if (bop) ! 76: *bop = ofs % pmp->pm_fatblocksize; ! 77: } ! 78: ! 79: /* ! 80: * Map the logical cluster number of a file into ! 81: * a physical disk sector that is filesystem relative. ! 82: * dep - address of denode representing the file of interest ! 83: * findcn - file relative cluster whose filesystem relative ! 84: * cluster number and/or block number are/is to be found ! 85: * bnp - address of where to place the file system relative ! 86: * block number. If this pointer is null then don't return ! 87: * this quantity. ! 88: * cnp - address of where to place the file system relative ! 89: * cluster number. If this pointer is null then don't return ! 90: * this quantity. ! 91: * NOTE: ! 92: * Either bnp or cnp must be non-null. ! 93: * This function has one side effect. If the requested ! 94: * file relative cluster is beyond the end of file, then ! 95: * the actual number of clusters in the file is returned ! 96: * in *cnp. This is useful for determining how long a ! 97: * directory is. If cnp is null, nothing is returned. ! 98: */ ! 99: int ! 100: pcbmap(dep, findcn, bnp, cnp) ! 101: struct denode *dep; ! 102: u_long findcn; /* file relative cluster to get */ ! 103: daddr_t *bnp; /* returned filesys relative blk number */ ! 104: u_long *cnp; /* returned cluster number */ ! 105: { ! 106: int error; ! 107: u_long i; ! 108: u_long cn; ! 109: u_long prevcn; ! 110: u_long byteoffset; ! 111: u_long bn; ! 112: u_long bo; ! 113: struct buf *bp = NULL; ! 114: u_long bp_bn = -1; ! 115: struct pcfsmount *pmp = dep->de_pmp; ! 116: u_long bsize; ! 117: int fat12 = FAT12(pmp); /* 12 bit fat */ ! 118: ! 119: fc_bmapcalls++; ! 120: ! 121: /* ! 122: * If they don't give us someplace to return a value ! 123: * then don't bother doing anything. ! 124: */ ! 125: if (bnp == NULL && cnp == NULL) ! 126: return 0; ! 127: ! 128: cn = dep->de_StartCluster; ! 129: /* ! 130: * The "file" that makes up the root directory is contiguous, ! 131: * permanently allocated, of fixed size, and is not made up ! 132: * of clusters. If the cluster number is beyond the end of ! 133: * the root directory, then return the number of clusters in ! 134: * the file. ! 135: */ ! 136: if (cn == PCFSROOT) { ! 137: if (dep->de_Attributes & ATTR_DIRECTORY) { ! 138: if (findcn * pmp->pm_SectPerClust > pmp->pm_rootdirsize) { ! 139: if (cnp) ! 140: *cnp = pmp->pm_rootdirsize / pmp->pm_SectPerClust; ! 141: return E2BIG; ! 142: } ! 143: if (bnp) ! 144: *bnp = pmp->pm_rootdirblk + (findcn * pmp->pm_SectPerClust); ! 145: if (cnp) ! 146: *cnp = PCFSROOT; ! 147: return 0; ! 148: } ! 149: else { /* just an empty file */ ! 150: if (cnp) ! 151: *cnp = 0; ! 152: return E2BIG; ! 153: } ! 154: } ! 155: ! 156: /* ! 157: * Rummage around in the fat cache, maybe we can avoid ! 158: * tromping thru every fat entry for the file. ! 159: * And, keep track of how far off the cache was from ! 160: * where we wanted to be. ! 161: */ ! 162: i = 0; ! 163: fc_lookup(dep, findcn, &i, &cn); ! 164: if ((bn = findcn - i) >= LMMAX) ! 165: fc_largedistance++; ! 166: else ! 167: fc_lmdistance[bn]++; ! 168: ! 169: /* ! 170: * Handle all other files or directories the normal way. ! 171: */ ! 172: for (; i < findcn; i++) { ! 173: if (PCFSEOF(cn)) ! 174: goto hiteof; ! 175: byteoffset = FATOFS(pmp, cn); ! 176: fatblock(pmp, byteoffset, &bn, &bsize, &bo); ! 177: if (bn != bp_bn) { ! 178: if (bp) ! 179: brelse(bp); ! 180: error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp); ! 181: if (error) { ! 182: brelse(bp); ! 183: return error; ! 184: } ! 185: bp_bn = bn; ! 186: } ! 187: prevcn = cn; ! 188: cn = getushort(&bp->b_un.b_addr[bo]); ! 189: if (fat12) { ! 190: if (prevcn & 1) ! 191: cn >>= 4; ! 192: cn &= 0x0fff; ! 193: /* ! 194: * Force the special cluster numbers in the range ! 195: * 0x0ff0-0x0fff to be the same as for 16 bit cluster ! 196: * numbers to let the rest of pcfs think it is always ! 197: * dealing with 16 bit fats. ! 198: */ ! 199: if ((cn & 0x0ff0) == 0x0ff0) ! 200: cn |= 0xf000; ! 201: } ! 202: } ! 203: ! 204: if (!PCFSEOF(cn)) { ! 205: if (bp) ! 206: brelse(bp); ! 207: if (bnp) ! 208: *bnp = cntobn(pmp, cn); ! 209: if (cnp) ! 210: *cnp = cn; ! 211: fc_setcache(dep, FC_LASTMAP, i, cn); ! 212: return 0; ! 213: } ! 214: ! 215: hiteof:; ! 216: if (cnp) ! 217: *cnp = i; ! 218: if (bp) ! 219: brelse(bp); ! 220: /* update last file cluster entry in the fat cache */ ! 221: fc_setcache(dep, FC_LASTFC, i-1, prevcn); ! 222: return E2BIG; ! 223: } ! 224: ! 225: /* ! 226: * Find the closest entry in the fat cache to the ! 227: * cluster we are looking for. ! 228: */ ! 229: fc_lookup(dep, findcn, frcnp, fsrcnp) ! 230: struct denode *dep; ! 231: u_long findcn; ! 232: u_long *frcnp; ! 233: u_long *fsrcnp; ! 234: { ! 235: int i; ! 236: u_long cn; ! 237: struct fatcache *closest = 0; ! 238: ! 239: for (i = 0; i < FC_SIZE; i++) { ! 240: cn = dep->de_fc[i].fc_frcn; ! 241: if (cn != FCE_EMPTY && cn <= findcn) { ! 242: if (closest == 0 || cn > closest->fc_frcn) ! 243: closest = &dep->de_fc[i]; ! 244: } ! 245: } ! 246: if (closest) { ! 247: *frcnp = closest->fc_frcn; ! 248: *fsrcnp = closest->fc_fsrcn; ! 249: } ! 250: } ! 251: ! 252: /* ! 253: * Purge the fat cache in denode dep of all entries ! 254: * relating to file relative cluster frcn and beyond. ! 255: */ ! 256: fc_purge(dep, frcn) ! 257: struct denode *dep; ! 258: u_int frcn; ! 259: { ! 260: int i; ! 261: struct fatcache *fcp; ! 262: ! 263: fcp = dep->de_fc; ! 264: for (i = 0; i < FC_SIZE; i++, fcp++) { ! 265: if (fcp->fc_frcn != FCE_EMPTY && fcp->fc_frcn >= frcn) ! 266: fcp->fc_frcn = FCE_EMPTY; ! 267: } ! 268: } ! 269: ! 270: /* ! 271: * Once the first fat is updated the other copies of ! 272: * the fat must also be updated. This function does ! 273: * this. ! 274: * pmp - pcfsmount structure for filesystem to update ! 275: * bp - addr of modified fat block ! 276: * fatbn - block number relative to begin of filesystem ! 277: * of the modified fat block. ! 278: */ ! 279: void ! 280: updateotherfats(pmp, bp, fatbn) ! 281: struct pcfsmount *pmp; ! 282: struct buf *bp; ! 283: u_long fatbn; ! 284: { ! 285: int i; ! 286: struct buf *bpn; ! 287: ! 288: #if defined(PCFSDEBUG) ! 289: printf("updateotherfats(pmp %08x, bp %08x, fatbn %d)\n", ! 290: pmp, bp, fatbn); ! 291: #endif /* defined(PCFSDEBUG) */ ! 292: ! 293: /* ! 294: * Now copy the block(s) of the modified fat to the other ! 295: * copies of the fat and write them out. This is faster ! 296: * than reading in the other fats and then writing them ! 297: * back out. This could tie up the fat for quite a while. ! 298: * Preventing others from accessing it. To prevent us ! 299: * from going after the fat quite so much we use delayed ! 300: * writes, unless they specfied "synchronous" when the ! 301: * filesystem was mounted. If synch is asked for then ! 302: * use bwrite()'s and really slow things down. ! 303: */ ! 304: for (i = 1; i < pmp->pm_FATs; i++) { ! 305: fatbn += pmp->pm_FATsecs; ! 306: /* getblk() never fails */ ! 307: bpn = getblk(pmp->pm_devvp, fatbn, bp->b_bcount); ! 308: bcopy(bp->b_un.b_addr, bpn->b_un.b_addr, ! 309: bp->b_bcount); ! 310: if (pmp->pm_waitonfat) ! 311: bwrite(bpn); ! 312: else ! 313: bdwrite(bpn); ! 314: } ! 315: } ! 316: ! 317: /* ! 318: * Updating entries in 12 bit fats is a pain in the butt. ! 319: * ! 320: * The following picture shows where nibbles go when ! 321: * moving from a 12 bit cluster number into the appropriate ! 322: * bytes in the FAT. ! 323: * ! 324: * byte m byte m+1 byte m+2 ! 325: * +----+----+ +----+----+ +----+----+ ! 326: * | 0 1 | | 2 3 | | 4 5 | FAT bytes ! 327: * +----+----+ +----+----+ +----+----+ ! 328: * ! 329: * +----+----+----+ +----+----+----+ ! 330: * | 3 0 1 | | 4 5 2 | ! 331: * +----+----+----+ +----+----+----+ ! 332: * cluster n cluster n+1 ! 333: * ! 334: * Where n is even. ! 335: * m = n + (n >> 2) ! 336: * ! 337: * (Function no longer used) ! 338: */ ! 339: ! 340: ! 341: extern inline void ! 342: usemap_alloc (struct pcfsmount *pmp, u_long cn) ! 343: { ! 344: pmp->pm_inusemap[cn / 8] |= 1 << (cn % 8); ! 345: pmp->pm_freeclustercount--; ! 346: /* This assumes that the lowest available cluster was allocated */ ! 347: pmp->pm_lookhere = cn + 1; ! 348: } ! 349: ! 350: extern inline void ! 351: usemap_free (struct pcfsmount *pmp, u_long cn) ! 352: { ! 353: pmp->pm_freeclustercount++; ! 354: pmp->pm_inusemap[cn / 8] &= ~(1 << (cn % 8)); ! 355: if (pmp->pm_lookhere > cn) ! 356: pmp->pm_lookhere = cn; ! 357: } ! 358: ! 359: int ! 360: clusterfree(pmp, cluster, oldcnp) ! 361: struct pcfsmount *pmp; ! 362: u_long cluster; ! 363: u_long *oldcnp; ! 364: { ! 365: int error; ! 366: u_long oldcn; ! 367: ! 368: error = fatentry(FAT_GET_AND_SET, pmp, cluster, &oldcn, PCFSFREE); ! 369: if (error == 0) { ! 370: /* ! 371: * If the cluster was successfully marked free, then update the count of ! 372: * free clusters, and turn off the "allocated" bit in the ! 373: * "in use" cluster bit map. ! 374: */ ! 375: usemap_free(pmp, cluster); ! 376: if (oldcnp) ! 377: *oldcnp = oldcn; ! 378: } ! 379: return error; ! 380: } ! 381: ! 382: /* ! 383: * Get or Set or 'Get and Set' the cluster'th entry in the ! 384: * fat. ! 385: * function - whether to get or set a fat entry ! 386: * pmp - address of the pcfsmount structure for the ! 387: * filesystem whose fat is to be manipulated. ! 388: * cluster - which cluster is of interest ! 389: * oldcontents - address of a word that is to receive ! 390: * the contents of the cluster'th entry if this is ! 391: * a get function ! 392: * newcontents - the new value to be written into the ! 393: * cluster'th element of the fat if this is a set ! 394: * function. ! 395: * ! 396: * This function can also be used to free a cluster ! 397: * by setting the fat entry for a cluster to 0. ! 398: * ! 399: * All copies of the fat are updated if this is a set ! 400: * function. ! 401: * NOTE: ! 402: * If fatentry() marks a cluster as free it does not ! 403: * update the inusemap in the pcfsmount structure. ! 404: * This is left to the caller. ! 405: */ ! 406: int ! 407: fatentry(function, pmp, cn, oldcontents, newcontents) ! 408: int function; ! 409: struct pcfsmount *pmp; ! 410: u_long cn; ! 411: u_long *oldcontents; ! 412: u_long newcontents; ! 413: { ! 414: int error; ! 415: u_long readcn; ! 416: u_long bn, bo, bsize, byteoffset; ! 417: struct buf *bp; ! 418: /*printf("fatentry(func %d, pmp %08x, clust %d, oldcon %08x, newcon %d)\n", ! 419: function, pmp, cluster, oldcontents, newcontents);*/ ! 420: ! 421: #ifdef DIAGNOSTIC ! 422: /* ! 423: * Be sure they asked us to do something. ! 424: */ ! 425: if ((function & (FAT_SET | FAT_GET)) == 0) { ! 426: printf("fatentry(): function code doesn't specify get or set\n"); ! 427: return EINVAL; ! 428: } ! 429: ! 430: /* ! 431: * If they asked us to return a cluster number ! 432: * but didn't tell us where to put it, give them ! 433: * an error. ! 434: */ ! 435: if ((function & FAT_GET) && oldcontents == NULL) { ! 436: printf("fatentry(): get function with no place to put result\n"); ! 437: return EINVAL; ! 438: } ! 439: #endif ! 440: ! 441: /* ! 442: * Be sure the requested cluster is in the filesystem. ! 443: */ ! 444: if (cn < CLUST_FIRST || cn > pmp->pm_maxcluster) ! 445: return EINVAL; ! 446: ! 447: byteoffset = FATOFS(pmp, cn); ! 448: fatblock(pmp, byteoffset, &bn, &bsize, &bo); ! 449: error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp); ! 450: if (error) { ! 451: brelse(bp); ! 452: return error; ! 453: } ! 454: if (function & FAT_GET) { ! 455: readcn = getushort(&bp->b_un.b_addr[bo]); ! 456: if (FAT12(pmp)) { ! 457: if (cn & 1) ! 458: readcn >>= 4; ! 459: readcn &= 0x0fff; ! 460: /* map certain 12 bit fat entries to 16 bit */ ! 461: if ((readcn & 0x0ff0) == 0x0ff0) ! 462: readcn |= 0xf000; ! 463: } ! 464: *oldcontents = readcn; ! 465: } ! 466: if (function & FAT_SET) { ! 467: if (FAT12(pmp)) { ! 468: readcn = getushort(&bp->b_un.b_addr[bo]); ! 469: if (cn & 1) { ! 470: readcn &= 0x000f; ! 471: readcn |= (newcontents << 4); ! 472: } ! 473: else { ! 474: readcn &= 0xf000; ! 475: readcn |= (newcontents << 0); ! 476: } ! 477: putushort(&bp->b_un.b_addr[bo], readcn); ! 478: } ! 479: else ! 480: putushort(&bp->b_un.b_addr[bo], newcontents); ! 481: updateotherfats(pmp, bp, bn); ! 482: /* ! 483: * Write out the first fat last. ! 484: */ ! 485: if (pmp->pm_waitonfat) ! 486: bwrite(bp); ! 487: else ! 488: bdwrite(bp); ! 489: bp = NULL; ! 490: pmp->pm_fmod++; ! 491: } ! 492: if (bp) ! 493: brelse(bp); ! 494: return 0; ! 495: } ! 496: ! 497: /* ! 498: * Allocate a free cluster. ! 499: * pmp - ! 500: * retcluster - put the allocated cluster's number here. ! 501: * fillwith - put this value into the fat entry for the ! 502: * allocated cluster. ! 503: */ ! 504: int ! 505: clusteralloc(pmp, retcluster, fillwith) ! 506: struct pcfsmount *pmp; ! 507: u_long *retcluster; ! 508: u_long fillwith; ! 509: { ! 510: int error; ! 511: u_long cn; ! 512: u_long idx, max_idx, bit, map; ! 513: ! 514: max_idx = pmp->pm_maxcluster / 8; ! 515: for (idx = pmp->pm_lookhere / 8; idx <= max_idx; idx++) { ! 516: map = pmp->pm_inusemap[idx]; ! 517: if (map != 0xff) { ! 518: for (bit = 0; bit < 8; bit++) { ! 519: if ((map & (1 << bit)) == 0) { ! 520: cn = idx * 8 + bit; ! 521: goto found_one; ! 522: } ! 523: } ! 524: } ! 525: } ! 526: return ENOSPC; ! 527: ! 528: found_one:; ! 529: error = fatentry(FAT_SET, pmp, cn, 0, fillwith); ! 530: if (error == 0) { ! 531: usemap_alloc(pmp, cn); ! 532: *retcluster = cn; ! 533: } ! 534: #if defined(PCFSDEBUG) ! 535: printf("clusteralloc(): allocated cluster %d\n", cn); ! 536: #endif /* defined(PCFSDEBUG) */ ! 537: return error; ! 538: } ! 539: ! 540: /* ! 541: * Free a chain of clusters. ! 542: * pmp - address of the pcfs mount structure for the ! 543: * filesystem containing the cluster chain to be freed. ! 544: * startcluster - number of the 1st cluster in the chain ! 545: * of clusters to be freed. ! 546: */ ! 547: int ! 548: freeclusterchain(pmp, startcluster) ! 549: struct pcfsmount *pmp; ! 550: u_long startcluster; ! 551: { ! 552: u_long nextcluster; ! 553: int error = 0; ! 554: ! 555: while (startcluster >= CLUST_FIRST && startcluster <= pmp->pm_maxcluster) { ! 556: error = clusterfree(pmp, startcluster, &nextcluster); ! 557: if (error) { ! 558: printf("freeclusterchain(): free failed, cluster %d\n", ! 559: startcluster); ! 560: break; ! 561: } ! 562: startcluster = nextcluster; ! 563: } ! 564: return error; ! 565: } ! 566: ! 567: /* ! 568: * Read in fat blocks looking for free clusters. ! 569: * For every free cluster found turn off its ! 570: * corresponding bit in the pm_inusemap. ! 571: */ ! 572: int ! 573: fillinusemap(pmp) ! 574: struct pcfsmount *pmp; ! 575: { ! 576: struct buf *bp = NULL; ! 577: u_long cn, readcn; ! 578: int error; ! 579: int fat12 = FAT12(pmp); ! 580: u_long bn, bo, bsize, byteoffset; ! 581: ! 582: /* ! 583: * Mark all clusters in use, we mark the free ones in the ! 584: * fat scan loop further down. ! 585: */ ! 586: for (cn = 0; cn < (pmp->pm_maxcluster >> 3) + 1; cn++) ! 587: pmp->pm_inusemap[cn] = 0xff; ! 588: ! 589: /* ! 590: * Figure how many free clusters are in the filesystem ! 591: * by ripping thougth the fat counting the number of ! 592: * entries whose content is zero. These represent free ! 593: * clusters. ! 594: */ ! 595: pmp->pm_freeclustercount = 0; ! 596: pmp->pm_lookhere = pmp->pm_maxcluster + 1; ! 597: for (cn = CLUST_FIRST; cn <= pmp->pm_maxcluster; cn++) { ! 598: byteoffset = FATOFS(pmp, cn); ! 599: bo = byteoffset % pmp->pm_fatblocksize; ! 600: if (!bo || !bp) { ! 601: /* Read new FAT block */ ! 602: if (bp) ! 603: brelse(bp); ! 604: fatblock(pmp, byteoffset, &bn, &bsize, NULL); ! 605: error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp); ! 606: if (error) { ! 607: brelse(bp); ! 608: return error; ! 609: } ! 610: } ! 611: readcn = getushort(&bp->b_un.b_addr[bo]); ! 612: if (fat12) { ! 613: if (cn & 1) ! 614: readcn >>= 4; ! 615: readcn &= 0x0fff; ! 616: } ! 617: ! 618: if (readcn == 0) ! 619: usemap_free(pmp, cn); ! 620: } ! 621: brelse(bp); ! 622: return 0; ! 623: } ! 624: ! 625: /* ! 626: * Allocate a new cluster and chain it onto the end of the ! 627: * file. ! 628: * dep - the file to extend ! 629: * bpp - where to return the address of the buf header for the ! 630: * new file block ! 631: * ncp - where to put cluster number of the newly allocated file block ! 632: * If this pointer is 0, do not return the cluster number. ! 633: * ! 634: * NOTE: ! 635: * This function is not responsible for turning on the DEUPD ! 636: * bit if the de_flag field of the denode and it does not ! 637: * change the de_FileSize field. This is left for the caller ! 638: * to do. ! 639: */ ! 640: int ! 641: extendfile(dep, bpp, ncp) ! 642: struct denode *dep; ! 643: struct buf **bpp; ! 644: u_int *ncp; ! 645: { ! 646: int error = 0; ! 647: u_long frcn; ! 648: u_long cn; ! 649: struct pcfsmount *pmp = dep->de_pmp; ! 650: ! 651: /* ! 652: * Don't try to extend the root directory ! 653: */ ! 654: if (DETOV(dep)->v_flag & VROOT) { ! 655: printf("extendfile(): attempt to extend root directory\n"); ! 656: return ENOSPC; ! 657: } ! 658: ! 659: /* ! 660: * If the "file's last cluster" cache entry is empty, ! 661: * and the file is not empty, ! 662: * then fill the cache entry by calling pcbmap(). ! 663: */ ! 664: fc_fileextends++; ! 665: if (dep->de_fc[FC_LASTFC].fc_frcn == FCE_EMPTY && ! 666: dep->de_StartCluster != 0) { ! 667: fc_lfcempty++; ! 668: error = pcbmap(dep, 0xffff, 0, &cn); ! 669: /* we expect it to return E2BIG */ ! 670: if (error != E2BIG) ! 671: return error; ! 672: error = 0; ! 673: } ! 674: ! 675: /* ! 676: * Allocate another cluster and chain onto the end of the file. ! 677: * If the file is empty we make de_StartCluster point to the ! 678: * new block. Note that de_StartCluster being 0 is sufficient ! 679: * to be sure the file is empty since we exclude attempts to ! 680: * extend the root directory above, and the root dir is the ! 681: * only file with a startcluster of 0 that has blocks allocated ! 682: * (sort of). ! 683: */ ! 684: if (error = clusteralloc(pmp, &cn, CLUST_EOFE)) ! 685: return error; ! 686: if (dep->de_StartCluster == 0) { ! 687: dep->de_StartCluster = cn; ! 688: frcn = 0; ! 689: } else { ! 690: error = fatentry(FAT_SET, pmp, dep->de_fc[FC_LASTFC].fc_fsrcn, ! 691: 0, cn); ! 692: if (error) { ! 693: clusterfree(pmp, cn, NULL); ! 694: return error; ! 695: } ! 696: ! 697: frcn = dep->de_fc[FC_LASTFC].fc_frcn + 1; ! 698: } ! 699: ! 700: /* ! 701: * Update the "last cluster of the file" entry in the denode's ! 702: * fat cache. ! 703: */ ! 704: fc_setcache(dep, FC_LASTFC, frcn, cn); ! 705: ! 706: /* ! 707: * Get the buf header for the new block of the file. ! 708: */ ! 709: if (dep->de_Attributes & ATTR_DIRECTORY) ! 710: *bpp = getblk(pmp->pm_devvp, cntobn(pmp, cn), ! 711: pmp->pm_bpcluster); ! 712: else ! 713: *bpp = getblk(DETOV(dep), frcn, pmp->pm_bpcluster); ! 714: clrbuf(*bpp); ! 715: ! 716: if (dep->de_Attributes & ATTR_DIRECTORY) ! 717: /* If we extend a directory, me must record the new size */ ! 718: dep->de_FileSize = (frcn + 1) * pmp->pm_bpcluster; ! 719: ! 720: /* ! 721: * Give them the filesystem relative cluster number ! 722: * if they want it. ! 723: */ ! 724: if (ncp) ! 725: *ncp = cn; ! 726: return 0; ! 727: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.