![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to MacOSStubs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / hfs|
Return to MacOSStubs.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / hfs |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* @(#)MacOSStubs.c 4.0
26: *
27: * (c) 1997-1998 Apple Computer, Inc. All Rights Reserved
28: *
29: * MacOSStubs.c -- Contains routines called by MacOS code, that is not defined.
30: *
31: * HISTORY
32: * 20-Nov-1998 Don Brady Remove UFSToHFSStr and HFSToUFSStr routines (obsolete).
33: * 31-Aug-1998 Don Brady Move DST adjustments to GetTimeLocal (radar #2265075).
34: * 28-Jul-1998 Don Brady Add GetDiskBlocks routine (radar #2258148).
35: * 23-Jul-1998 Don Brady Use bdwrite instead of bwrite for default in RelBlock_glue (radar #2257225).
36: * 7-Jul-1998 Don Brady Remove character mappings from/to hfs (ufs_hfs and hfs_ufs tables).
37: * 22-Jun-1998 Pat Dirks Added the vice versa mappings in ufs_hfs and hfs_ufs to more
38: * thoroughly interchange ":" and "/" in name strings.
39: * 4-Jun-1998 Pat Dirks Changed to do all B*-Tree writes synchronously (FORCESYNCBTREEWRITES = 1)
40: * 4-jun-1998 Don Brady Use VPUT macro instead of vput.
41: * 6-may-1998 Don Brady Bump h_devvp refcount in GetInitializedVNode (radar #2232480).
42: * 27-apr-1998 Don Brady Change printf to kprintf.
43: * 23-Apr-1998 Pat Dirks Cleaned up GetBlock_glue to add brelse on I/O errors from bread.
44: * 23-apr-1998 Don Brady Add '/' to ':' mapping and vice versa to mapping tables.
45: * 21-apr-1998 Don Brady Clean up time/date conversion routines.
46: * 11-apr-1998 Don Brady Add RequireFileLock routine.
47: * 8-apr-1998 Don Brady C_FlushMDB now calls hfs_flushvolumeheader and hfs_flushMDB.
48: * 12-nov-1997 Scott Roberts
49: * Initially created file.
50: *
51: */
52: #include <sys/types.h>
53: #include <sys/malloc.h>
54: #include <sys/kernel.h>
55: #include <libkern/libkern.h>
56: #include <sys/systm.h>
57: #include <bsd/dev/disk.h>
58: #include "hfs.h"
59: #include "hfs_dbg.h"
60:
61:
62: #include "hfscommon/headers/system/MacOSTypes.h"
63: #include "hfscommon/headers/system/MacOSStubs.h"
64: #include "hfscommon/headers/BTreesPrivate.h"
65:
66: extern int (**hfs_vnodeop_p)();
67:
68:
69: struct timezone gTimeZone = {8*60,1}; /*XXX need to dynamically set this global from HFS Util */
70:
71:
72: /*************************************************************************************/
73:
74: /*************************************************************************************/
75:
76: FCB* GetFileControlBlock(FileReference fref)
77: {
78: return VTOFCB(fref);
79: }
80:
81: FileReference GetFileRefNumFromFCB(const FCB *filePtr)
82: {
83: return (FileReference)FCBTOV(filePtr);
84: }
85:
86: /*
87: * The following two routines work in tandem: StoreBufferMapping stores
88: * successive buffer address -> buffer pointer mappings in a circular
89: * match list, advancing the list index forward each time, while LookupBufferMapping
90: * looks backwards through the list to look up a particular mapping (which is
91: * typically the entry currently pointed to by gBufferAddress).
92: *
93: */
94: static void StoreBufferMapping(caddr_t bufferAddress, struct buf *bp)
95: {
96: int i;
97:
98: DBG_ASSERT(gBufferListIndex >= 0);
99: DBG_ASSERT(gBufferListIndex < BUFFERPTRLISTSIZE);
100:
101: simple_lock(&gBufferPtrListLock);
102:
103: /* We've got at most BUFFERPTRLISTSIZE tries at this... */
104: for (i = BUFFERPTRLISTSIZE; i > 0; --i) {
105: if (gBufferAddress[gBufferListIndex] == NULL) {
106: gBufferAddress[gBufferListIndex] = bufferAddress;
107: gBufferHeaderPtr[gBufferListIndex] = bp;
108: break;
109: }
110: gBufferListIndex = (gBufferListIndex + 1) % BUFFERPTRLISTSIZE;
111: };
112:
113: if (i == 0) {
114: panic("StoreBufferMapping: couldn't find an empty slot in buffer list.");
115: };
116:
117: DBG_ASSERT(gBufferListIndex >= 0);
118: DBG_ASSERT(gBufferListIndex < BUFFERPTRLISTSIZE);
119:
120: simple_unlock(&gBufferPtrListLock);
121: }
122:
123:
124: /*static*/ OSErr LookupBufferMapping(caddr_t bufferAddress, struct buf **bpp, int *mappingIndexPtr)
125: {
126: OSErr err = E_NONE;
127: int i;
128: int listIndex = gBufferListIndex;
129: struct buf *bp = NULL;
130:
131: DBG_ASSERT(gBufferListIndex >= 0);
132: DBG_ASSERT(gBufferListIndex < BUFFERPTRLISTSIZE);
133:
134: simple_lock(&gBufferPtrListLock);
135:
136: /* We've got at most BUFFERPTRLISTSIZE tries at this... */
137: for (i = BUFFERPTRLISTSIZE; i > 0; --i) {
138: if (gBufferAddress[listIndex] == bufferAddress) {
139: *mappingIndexPtr = listIndex;
140: bp = gBufferHeaderPtr[listIndex];
141: break;
142: };
143:
144: listIndex = (listIndex - 1);
145: if (listIndex < 0) {
146: listIndex = BUFFERPTRLISTSIZE - 1;
147: };
148: };
149:
150: if (bp == NULL) {
151: DEBUG_BREAK_MSG(("LookupBufferMapping: couldn't find buffer header for buffer in list.\n"));
152: err = -1;
153: };
154:
155: DBG_ASSERT(gBufferListIndex >= 0);
156: DBG_ASSERT(gBufferListIndex < BUFFERPTRLISTSIZE);
157:
158: simple_unlock(&gBufferPtrListLock);
159:
160: *bpp = bp;
161: return err;
162: }
163:
164:
165: static void ReleaseMappingEntry(int entryIndex) {
166:
167: DBG_ASSERT(gBufferListIndex >= 0);
168: DBG_ASSERT(gBufferListIndex < BUFFERPTRLISTSIZE);
169:
170: simple_lock(&gBufferPtrListLock);
171: gBufferAddress[entryIndex] = NULL;
172: simple_unlock(&gBufferPtrListLock);
173: };
174: #if DIAGNOSTIC
175: #define DBG_GETBLOCK 0
176: #else
177: #define DBG_GETBLOCK 0
178: #endif
179:
180: OSErr GetBlock_glue (UInt16 options, UInt32 blockNum, Ptr *baddress, FileReference fileRefNum, ExtendedVCB * vcb)
181: {
182: int status;
183: struct buf *bp = NULL;
184: int readcount = 0;
185:
186: #if DBG_GETBLOCK
187: DBG_IO(("Getting block %ld with options %d and a refnum of %x\n", blockNum, options, fileRefNum ));
188: #endif
189:
190: if ((options & ~(gbReadMask | gbNoReadMask)) != 0) {
191: DEBUG_BREAK_MSG(("GetBlock_glue: options = 0x%04X.\n", options));
192: };
193:
194: *baddress = NULL;
195:
196: if (options & gbNoReadMask) {
197: if (fileRefNum == NULL) {
198: bp = getblk (VCBTOHFS(vcb)->hfs_devvp,
199: IOBLKNOFORBLK(blockNum, VCBTOHFS(vcb)->hfs_phys_block_size),
200: IOBYTECCNTFORBLK(blockNum, kHFSBlockSize, VCBTOHFS(vcb)->hfs_phys_block_size),
201: 0,
202: 0);
203: } else {
204: bp = getblk (fileRefNum,
205: IOBLKNOFORBLK(blockNum, VCBTOHFS(vcb)->hfs_phys_block_size),
206: IOBYTECCNTFORBLK(blockNum, kHFSBlockSize, VCBTOHFS(vcb)->hfs_phys_block_size),
207: 0,
208: 0);
209: };
210: status = E_NONE;
211: } else {
212: do {
213: if (fileRefNum == NULL) {
214: status = bread (VCBTOHFS(vcb)->hfs_devvp,
215: IOBLKNOFORBLK(blockNum, VCBTOHFS(vcb)->hfs_phys_block_size),
216: IOBYTECCNTFORBLK(blockNum, kHFSBlockSize, VCBTOHFS(vcb)->hfs_phys_block_size),
217: NOCRED,
218: &bp);
219: } else {
220: status = bread (fileRefNum,
221: IOBLKNOFORBLK(blockNum, VCBTOHFS(vcb)->hfs_phys_block_size),
222: IOBYTECCNTFORBLK(blockNum, kHFSBlockSize, VCBTOHFS(vcb)->hfs_phys_block_size),
223: NOCRED,
224: &bp);
225: };
226: if (status != E_NONE) {
227: if (bp) brelse(bp);
228: goto Error_Exit;
229: };
230:
231: if (bp == NULL) {
232: status = -1;
233: goto Error_Exit;
234: };
235:
236: ++readcount;
237:
238: if ((options & gbReadMask) && (bp->b_flags & B_CACHE)) {
239: /* Rats! The block was found in the cache just when we really wanted a
240: fresh copy off disk...
241: */
242: if (bp->b_flags & B_DIRTY) {
243: DEBUG_BREAK_MSG(("GetBlock_glue: forced read for dirty block!\n"))
244: };
245: bp->b_flags |= B_INVAL;
246: brelse(bp);
247:
248: /* Fall through and try again until we get a fresh copy from the disk... */
249: };
250: } while (((options & gbReadMask) != 0) && (readcount <= 1));
251: };
252:
253: *baddress = bp->b_data + IOBYTEOFFSETFORBLK(bp->b_blkno, VCBTOHFS(vcb)->hfs_phys_block_size);
254: StoreBufferMapping(*baddress, bp);
255:
256: Error_Exit: ;
257: return status;
258: }
259:
260: void MarkBlock_glue (Ptr address)
261: {
262: int err;
263: struct buf *bp = NULL;
264: int mappingEntry;
265:
266: if ((err = LookupBufferMapping(address, &bp, &mappingEntry))) {
267: PANIC("Failed to find buffer pointer for buffer in MarkBlock_glue.");
268: } else {
269: bp->b_flags |= B_DIRTY;
270: };
271: }
272:
273: OSErr RelBlock_glue (Ptr address, UInt16 options )
274: {
275: int err;
276: struct buf *bp;
277: int mappingEntry;
278:
279: if (options & ~(rbTrashMask | rbDirtyMask | rbWriteMask) == 0) {
280: DEBUG_BREAK_MSG(("RelBlock_glue: options = 0x%04X.\n", options));
281: };
282:
283: if ((err = LookupBufferMapping(address, &bp, &mappingEntry))) {
284: DEBUG_BREAK_MSG(("Failed to find buffer pointer for buffer in RelBlock_glue.\n"));
285: } else {
286: if (bp->b_flags & B_DIRTY) {
287: /* The buffer was previously marked dirty (using MarkBlock_glue):
288: now's the time to write it. */
289: options |= rbDirtyMask;
290: };
291: ReleaseMappingEntry(mappingEntry);
292: if (options & rbTrashMask) {
293: bp->b_flags |= B_INVAL;
294: brelse(bp);
295: } else {
296: if (options & (rbDirtyMask | rbWriteMask)) {
297: bp->b_flags |= B_DIRTY;
298: if (options & rbWriteMask) {
299: bwrite(bp);
300: } else {
301: bdwrite(bp);
302: }
303: } else {
304: brelse(bp);
305: };
306: };
307: err = E_NONE;
308: };
309: return err;
310: }
311:
312: /* */
313: /* Creates a new vnode to hold a psuedo file like an extents tree file */
314: /* */
315:
316: OSStatus GetInitializedVNode(struct hfsmount *hfsmp, struct vnode **tmpvnode )
317: {
318:
319: struct hfsnode *hp;
320: struct vnode *vp = NULL;
321: int rtn;
322:
323: DBG_ASSERT(hfsmp != NULL);
324: DBG_ASSERT(tmpvnode != NULL);
325:
326: /* Allocate a new hfsnode. */
327: /* Must malloc() here, since getnewvnode() can sleep */
328: MALLOC(hp, struct hfsnode *, sizeof(struct hfsnode), M_HFSNODE, M_WAITOK);
329: if(hp == NULL) {
330: rtn = ENOMEM;
331: goto Err_Exit;
332: }
333: bzero((caddr_t)hp, sizeof(struct hfsnode));
334: lockinit(&hp->h_lock, PINOD, "hfsnode", 0, 0);
335:
336: /* Allocate a new vnode. */
337: if ((rtn = getnewvnode(VT_HFS, HFSTOVFS(hfsmp), hfs_vnodeop_p, &vp))) {
338: goto Err_Exit;
339: }
340:
341: /* Init the structure */
342: MALLOC(hp->h_meta, struct hfsfilemeta *, sizeof(struct hfsfilemeta), M_HFSNODE, M_WAITOK);
343: bzero(hp->h_meta, sizeof(struct hfsfilemeta));
344: lockinit(&hp->h_meta->h_fmetalock, PINOD, "hfsfilemeta", 0, 0);
345: MALLOC(hp->h_xfcb, struct vfsFCB *, sizeof(struct vfsFCB), M_HFSNODE, M_WAITOK);
346: bzero(hp->h_xfcb, sizeof(struct vfsFCB));
347:
348: hp->h_vp = vp; /* Make HFSTOV work */
349: hp->h_xfcb->fcb_vp = vp; /* Make FCBTOV work */
350: hp->h_devvp = hfsmp->hfs_devvp;
351: hp->h_dev = hfsmp->hfs_raw_dev;
352: hp->h_meta->h_logBlockSize = hfsmp->hfs_log_block_size;
353: hp->h_meta->h_physBlkPerLogBlk = hp->h_meta->h_logBlockSize/kHFSBlockSize;
354: hp->h_meta->h_nodeflags |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
355: hp->h_valid = HFS_VNODE_MAGIC;
356:
357: vp->v_data = hp; /* Make VTOH work */
358: vp->v_type = VREG;
359:
360: *tmpvnode = vp;
361:
362: VREF(hp->h_devvp);
363:
364: return noErr;
365:
366: Err_Exit:
367: if (vp)
368: {
369: VPUT(vp);
370: vp->v_type = VNON;
371: vgone(vp);
372: }
373:
374: *tmpvnode = NULL;
375:
376: return rtn;
377: }
378:
379: OSErr GetNewFCB(ExtendedVCB *vcb, FileReference* fRefPtr)
380: {
381: OSErr err;
382:
383: err = GetInitializedVNode( VCBTOHFS(vcb), fRefPtr );
384: panic("This node is not completely initialized in GetNewFCB!"); /* XXX SER */
385:
386: return( err );
387: }
388:
389: Boolean BlockCameFromDisk()
390: {
391: /* Did the last block read, really come from a disk hit */
392: return true;
393:
394: }
395:
396:
397: /*
398: * Mac OS Stubs
399: */
400: void UprText (Ptr textPtr, short len)
401: {
402: char * cptr;
403: char c;
404: int count;
405:
406: for (cptr = (char *)textPtr, count = len; count > 0; --count) {
407: c = *cptr;
408: *(cptr++) = (('a' <= c) && (c <= 'z')) ? c - ('a' - 'A') : c;
409: };
410: }
411:
412:
413:
414: Boolean CaseAndMarkSensitiveEqualString (void * str1,
415: void * str2,
416: unsigned long firstStringLength,
417: unsigned long secondStringLength)
418:
419: {
420: return (strncmp(str1, str2, max (firstStringLength,secondStringLength)));
421:
422: }
423:
424:
425: Ptr PLstrstr(ConstStr255Param str1, ConstStr255Param str2)
426: {
427: int searchStringLength, targetStringLength;
428: char searchString[256];
429: char targetString[256];
430: Ptr searchResult;
431:
432: searchStringLength = (int)str1[0];
433: memcpy(searchString, str1+1, searchStringLength);
434: searchString[searchStringLength] = (char)0;
435:
436: targetStringLength = (int)str2[0];
437: memcpy(targetString, str2+1, targetStringLength);
438: targetString[targetStringLength] = (char)0;
439:
440: /*
441: Do the search on the newly created search string but if the search
442: returns a non-NULL result return a pointer that's the same offset
443: into the original Pascal search string.
444: */
445: if ((searchResult = (Ptr)strstr(searchString, targetString))) {
446: searchResult = (const Ptr)(str1 + 1 + (searchResult - (Ptr)searchString));
447: };
448:
449: return searchResult;
450: }
451:
452:
453: OSErr CheckVolumeOffLine( ExtendedVCB *vcb )
454: {
455:
456: return( 0 );
457: }
458:
459:
460: OSErr C_FlushMDB( ExtendedVCB *volume)
461: {
462: short err;
463:
464: if (volume->vcbSigWord == kHFSPlusSigWord)
465: err = hfs_flushvolumeheader(VCBTOHFS(volume), MNT_WAIT);
466: else
467: err = hfs_flushMDB(VCBTOHFS(volume), MNT_WAIT);
468:
469: return err;
470: }
471:
472:
473: /*
474: * GetTimeUTC - get the GMT Mac OS time (in seconds since 1/1/1904)
475: *
476: * called by the Catalog Manager when creating/updating records
477: */
478: UInt32 GetTimeUTC(void)
479: {
480: return (time.tv_sec + MAC_GMT_FACTOR);
481: }
482:
483: /*
484: * GetTimeLocal - get the local Mac OS time (in seconds since 1/1/1904)
485: *
486: * called by the Catalog Manager when creating/updating records
487: * also used to update the VCB last modify date
488: */
489: UInt32 GetTimeLocal(Boolean forHFS)
490: {
491: UInt32 localTime;
492:
493: localTime = UTCToLocal(GetTimeUTC());
494:
495: if (forHFS && gTimeZone.tz_dsttime)
496: localTime += 3600;
497:
498: return localTime;
499: }
500:
501: /*
502: * LocalToUTC - convert from Mac OS local time to Mac OS GMT time
503: */
504: UInt32 LocalToUTC(UInt32 localTime)
505: {
506: UInt32 gtime = localTime;
507:
508: if (gtime != 0) {
509: gtime += (gTimeZone.tz_minuteswest * 60);
510: /*
511: * We no longer do DST adjustments here since we don't
512: * know if time supplied needs adjustment!
513: *
514: * if (gTimeZone.tz_dsttime)
515: * gtime -= 3600;
516: */
517: }
518: return (gtime);
519: }
520:
521: /*
522: * UTCToLocal - convert from Mac OS GMT time to Mac OS local time
523: */
524: UInt32 UTCToLocal(UInt32 utcTime)
525: {
526: UInt32 ltime = utcTime;
527:
528: if (ltime != 0) {
529: ltime -= (gTimeZone.tz_minuteswest * 60);
530: /*
531: * We no longer do DST adjustments here since we don't
532: * know if time supplied needs adjustment!
533: *
534: * if (gTimeZone.tz_dsttime)
535: * ltime += 3600;
536: */
537: }
538: return (ltime);
539: }
540:
541: /*
542: * to_bsd_time - convert from Mac OS local time (seconds since 1/1/1904) to
543: * BSD time (seconds since 1/1/1970)
544: */
545: u_int32_t to_bsd_time(u_int32_t hfs_time)
546: {
547: u_int32_t gmt = LocalToUTC(hfs_time);
548:
549: if (gmt > MAC_GMT_FACTOR)
550: gmt -= MAC_GMT_FACTOR;
551: else
552: gmt = 0; /* don't let date go negative! */
553:
554: return gmt;
555: }
556:
557: /*
558: * to_hfs_time - convert from BSD time (seconds since 1/1/1970) to
559: * Mac OS local time (seconds since 1/1/1904)
560: */
561: u_int32_t to_hfs_time(u_int32_t bsd_time)
562: {
563: u_int32_t local = bsd_time;
564:
565: /* don't adjust zero - treat as uninitialzed */
566: if (local != 0)
567: local += MAC_GMT_FACTOR;
568:
569: return UTCToLocal(local);
570: }
571:
572:
573: void BlockMove (const void *srcPtr, void *destPtr, Size byteCount)
574: {
575:
576: bcopy(srcPtr, destPtr, byteCount);
577: }
578:
579: void BlockMoveData (const void *srcPtr, void *destPtr, Size byteCount)
580: {
581:
582: bcopy(srcPtr, destPtr, byteCount);
583: }
584:
585: Ptr NewPtr (Size byteCount)
586: {
587: Ptr tmptr;
588: MALLOC (tmptr, Ptr, byteCount , M_TEMP, M_WAITOK);
589: return tmptr;
590: }
591:
592: Ptr NewPtrClear (Size byteCount)
593: {
594: Ptr tmptr;
595: MALLOC (tmptr, Ptr, byteCount, M_TEMP, M_WAITOK);
596: if (tmptr)
597: bzero(tmptr, byteCount);
598: return tmptr;
599: }
600:
601: Ptr NewPtrSys (Size byteCount)
602: {
603: Ptr tmptr;
604: MALLOC (tmptr, Ptr, byteCount , M_TEMP, M_WAITOK);
605: return tmptr;
606: }
607:
608: Ptr NewPtrSysClear (Size byteCount)
609: {
610: Ptr tmptr;
611: MALLOC (tmptr, Ptr, byteCount, M_TEMP, M_WAITOK);
612: if (tmptr)
613: bzero(tmptr, byteCount);
614: return tmptr;
615: }
616:
617: void DisposePtr (Ptr p)
618: {
619: FREE (p, M_TEMP);
620:
621: }
622:
623: void DebugStr (ConstStr255Param debuggerMsg)
624: {
625: kprintf ("*** Mac OS Debugging Message: %s\n", &debuggerMsg[1]);
626: DEBUG_BREAK;
627: }
628:
629: OSErr MemError (void)
630: {
631: return 0;
632: }
633:
634: /*
635: * GetDiskBlocks
636: *
637: * Calculate the total number of 512 byte disk blocks in a volume's
638: * partition. Used by caller to find the alternate MDB.
639: */
640: OSErr GetDiskBlocks(ExtendedVCB *vcb, unsigned long *numBlocks)
641: {
642: struct proc * p;
643: struct ucred * cred;
644: struct vnode * devvp;
645: unsigned long blocks;
646: unsigned long blksize;
647: int retval;
648:
649: devvp = VCBTOHFS(vcb)->hfs_devvp;
650: p = CURRENT_PROC;
651: cred = p ? p->p_ucred : NOCRED;
652:
653: retval = VOP_IOCTL(devvp, DKIOCNUMBLKS, &blocks, 0, cred, p);
654: if (retval) return retval;
655:
656: retval = VOP_IOCTL(devvp, DKIOCBLKSIZE, &blksize, 0, cred, p);
657: if (retval) return retval;
658:
659: if (blksize > 512) {
660: blocks *= (blksize / 512);
661: }
662:
663: *numBlocks = blocks;
664:
665: return noErr;
666: }
667:
668:
669: /*
670: * RequireFileLock
671: *
672: * Check to see if a vnode is locked in the current context
673: * This is to be used for debugging purposes only!!
674: */
675: #if DIAGNOSTIC
676: void RequireFileLock(FileReference vp, int shareable)
677: {
678: struct lock__bsd__ *lkp;
679: int locked = false;
680: pid_t pid;
681: void * self;
682:
683: pid = CURRENT_PROC->p_pid;
684: self = (void *) GET_CURRENT_THREAD;
685: lkp = &VTOH(vp)->h_lock;
686:
687: simple_lock(&lkp->lk_interlock);
688:
689: if (shareable && (lkp->lk_sharecount > 0) && (lkp->lk_lockholder == LK_NOPROC))
690: locked = true;
691: else if ((lkp->lk_exclusivecount > 0) && (lkp->lk_lockholder == pid) && (lkp->lk_lockthread == self))
692: locked = true;
693:
694: simple_unlock(&lkp->lk_interlock);
695:
696: if (!locked) {
697: DBG_VFS((" # context... self=0x%0X, pid=0x%0X, proc=0x%0X\n", (int)self, pid, (int)CURRENT_PROC));
698: DBG_VFS((" # lock state... thread=0x%0X, holder=0x%0X, ex=%d, sh=%d\n", (int)lkp->lk_lockthread, lkp->lk_lockholder, lkp->lk_exclusivecount, lkp->lk_sharecount));
699:
700: switch (H_FILEID(VTOH(vp))) {
701: case 3:
702: DEBUG_BREAK_MSG((" #\n # RequireFileLock: extent btree vnode not locked! v: 0x%08X\n #\n", (u_int)vp));
703: break;
704:
705: case 4:
706: DEBUG_BREAK_MSG((" #\n # RequireFileLock: catalog btree vnode not locked! v: 0x%08X\n #\n", (u_int)vp));
707: break;
708:
709: default:
710: DEBUG_BREAK_MSG((" #\n # RequireFileLock: file (%d) not locked! v: 0x%08X\n #\n", H_FILEID(VTOH(vp)), (u_int)vp));
711: break;
712: }
713: }
714: }
715: #endif
716:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.