497 params.iTid = aTid; |
497 params.iTid = aTid; |
498 params.iRHeapVTable = RHeapVTable(); |
498 params.iRHeapVTable = RHeapVTable(); |
499 params.iDebugAllocator = DebugEUser(); |
499 params.iDebugAllocator = DebugEUser(); |
500 params.iMasterInfo = &aInfo; |
500 params.iMasterInfo = &aInfo; |
501 // |
501 // |
502 TInt r = DoControl( EMemSpyDriverOpCodeHeapInfoGetUser, ¶ms, NULL ); |
502 TInt r = DoControl( EMemSpyDriverOpCodeHeapUserDataGetInfo, ¶ms, NULL ); |
503 // |
503 // |
504 if ( r == KErrNone ) |
504 if ( r == KErrNone ) |
505 { |
505 { |
506 PrintHeapInfo( aInfo ); |
506 PrintHeapInfo( aInfo ); |
507 |
507 |
521 } |
521 } |
522 // |
522 // |
523 return r; |
523 return r; |
524 } |
524 } |
525 |
525 |
526 EXPORT_C TInt RMemSpyDriverClient::GetHeapInfoUser( TMemSpyHeapInfo& aInfo, TUint aTid, RArray< TMemSpyDriverFreeCell >& aFreeCells ) |
526 EXPORT_C TInt RMemSpyDriverClient::GetHeapInfoUser(TMemSpyHeapInfo& aInfo, |
|
527 TUint aTid, |
|
528 RArray< TMemSpyDriverFreeCell >& aFreeCells) |
527 { |
529 { |
528 return GetHeapInfoUser(aInfo, aTid, aFreeCells, EFalse); |
530 return GetHeapInfoUser(aInfo, aTid, aFreeCells, EFalse); |
529 } |
531 } |
530 |
532 |
531 // For the record I don't think this function should be exported, but since the one above was I'm going with the flow. -TomS |
533 // For the record I don't think this function should be exported, but since the one above was I'm going with the flow. -TomS |
532 EXPORT_C TInt RMemSpyDriverClient::GetHeapInfoUser(TMemSpyHeapInfo& aInfo, TUint aTid, RArray<TMemSpyDriverCell>& aCells, TBool aCollectAllocatedCellsAsWellAsFree) |
534 EXPORT_C TInt RMemSpyDriverClient::GetHeapInfoUser(TMemSpyHeapInfo& aInfo, |
|
535 TUint aTid, |
|
536 RArray<TMemSpyDriverCell>& aCells, |
|
537 TBool aCollectAllocatedCellsAsWellAsFree) |
533 { |
538 { |
534 TMemSpyDriverInternalHeapRequestParameters params; |
539 TMemSpyDriverInternalHeapRequestParameters params; |
535 // |
540 // |
536 params.iTid = aTid; |
541 params.iTid = aTid; |
537 params.iRHeapVTable = RHeapVTable(); |
542 params.iRHeapVTable = RHeapVTable(); |
538 params.iDebugAllocator = DebugEUser(); |
543 params.iDebugAllocator = DebugEUser(); |
539 params.iMasterInfo = &aInfo; |
544 params.iMasterInfo = &aInfo; |
540 params.iBuildFreeCellList = ETrue; |
545 params.iBuildFreeCellList = ETrue; |
541 params.iBuildAllocCellList = aCollectAllocatedCellsAsWellAsFree; |
546 params.iBuildAllocCellList = aCollectAllocatedCellsAsWellAsFree; |
542 |
|
543 // |
547 // |
544 aCells.Reset(); |
548 aCells.Reset(); |
545 ResetStreamBuffer(); |
549 ResetStreamBuffer(); |
546 TInt r = DoControl( EMemSpyDriverOpCodeHeapInfoGetUser, ¶ms ); |
550 TInt r = DoControl( EMemSpyDriverOpCodeHeapUserDataGetInfo, ¶ms ); |
547 // |
551 // |
548 if ( r >= KErrNone ) |
552 if ( r >= KErrNone ) |
549 { |
553 { |
550 PrintHeapInfo( aInfo ); |
554 PrintHeapInfo( aInfo ); |
551 |
555 |
586 |
590 |
587 |
591 |
588 EXPORT_C TInt RMemSpyDriverClient::GetHeapInfoKernel( TMemSpyHeapInfo& aInfo ) |
592 EXPORT_C TInt RMemSpyDriverClient::GetHeapInfoKernel( TMemSpyHeapInfo& aInfo ) |
589 { |
593 { |
590 TMemSpyDriverInternalHeapRequestParameters params; |
594 TMemSpyDriverInternalHeapRequestParameters params; |
|
595 // |
591 params.iTid = KMemSpyDriverGetKernelHeapDataPseudoThreadId; |
596 params.iTid = KMemSpyDriverGetKernelHeapDataPseudoThreadId; |
592 params.iRHeapVTable = NULL; |
597 params.iRHeapVTable = NULL; |
593 params.iMasterInfo = &aInfo; |
598 params.iMasterInfo = &aInfo; |
594 TInt r = DoControl( EMemSpyDriverOpCodeHeapInfoGetKernel, ¶ms, NULL ); |
599 // |
|
600 TInt r = DoControl( EMemSpyDriverOpCodeHeapKernelDataGetInfo, ¶ms, NULL ); |
595 // |
601 // |
596 if ( r == KErrNone ) |
602 if ( r == KErrNone ) |
597 { |
603 { |
598 PrintHeapInfo( aInfo ); |
604 PrintHeapInfo( aInfo ); |
599 } |
605 } |
604 } |
610 } |
605 // |
611 // |
606 return r; |
612 return r; |
607 } |
613 } |
608 |
614 |
609 |
615 EXPORT_C TInt RMemSpyDriverClient::GetHeapInfoKernel(TMemSpyHeapInfo& aInfo, |
610 EXPORT_C TInt RMemSpyDriverClient::GetHeapInfoKernel( TMemSpyHeapInfo& aInfo, RArray< TMemSpyDriverFreeCell >& aFreeCells ) |
616 RArray< TMemSpyDriverFreeCell >& aFreeCells) |
|
617 { |
|
618 return GetHeapInfoKernel(aInfo, aFreeCells, EFalse, EFalse); |
|
619 } |
|
620 |
|
621 EXPORT_C TInt RMemSpyDriverClient::GetHeapInfoKernel(TMemSpyHeapInfo& aInfo, |
|
622 RArray<TMemSpyDriverCell>& aCells, |
|
623 TBool aCollectAllocatedCellsAsWellAsFree) |
|
624 { |
|
625 return GetHeapInfoKernel(aInfo, aCells, aCollectAllocatedCellsAsWellAsFree, EFalse); |
|
626 } |
|
627 |
|
628 EXPORT_C TInt RMemSpyDriverClient::GetHeapInfoKernel(TMemSpyHeapInfo& aInfo, |
|
629 RArray<TMemSpyDriverCell>& aCells, |
|
630 TBool aCollectAllocatedCellsAsWellAsFree, |
|
631 TBool aUseKernelCopy) |
611 { |
632 { |
612 TMemSpyDriverInternalHeapRequestParameters params; |
633 TMemSpyDriverInternalHeapRequestParameters params; |
613 params.iTid = KMemSpyDriverGetKernelHeapDataPseudoThreadId; |
634 // |
|
635 params.iTid = KMemSpyDriverGetKernelHeapDataPseudoThreadId; |
614 params.iRHeapVTable = NULL; |
636 params.iRHeapVTable = NULL; |
615 params.iMasterInfo = &aInfo; |
637 params.iMasterInfo = &aInfo; |
616 // |
638 params.iBuildFreeCellList = ETrue; |
617 aFreeCells.Reset(); |
639 params.iBuildAllocCellList = aCollectAllocatedCellsAsWellAsFree; |
|
640 params.iUseKernelHeapCopy = aUseKernelCopy; |
|
641 // |
|
642 aCells.Reset(); |
618 ResetStreamBuffer(); |
643 ResetStreamBuffer(); |
619 TInt r = DoControl( EMemSpyDriverOpCodeHeapInfoGetKernel, ¶ms, (TAny*) &iBuffer ); |
644 TInt r = DoControl( EMemSpyDriverOpCodeHeapKernelDataGetInfo, ¶ms ); |
620 // |
645 // |
621 if ( r == KErrNone ) |
646 if ( r >= KErrNone ) |
622 { |
647 { |
623 PrintHeapInfo( aInfo ); |
648 PrintHeapInfo( aInfo ); |
624 TRAP( r, ReadHeapInfoFreeCellsFromXferBufferL( aFreeCells ) ); |
649 |
|
650 // Resize transfer buffer to make room for free cells. We only make the buffer |
|
651 // bigger, not smaller. |
|
652 if ( iBuffer.Size() < r ) |
|
653 { |
|
654 r = iBuffer.ReAlloc( r ); |
|
655 } |
|
656 |
|
657 // Now fetch the heap data |
|
658 if ( r == KErrNone ) |
|
659 { |
|
660 r = DoControl( EMemSpyDriverOpCodeHeapKernelDataFetchCellList, &iBuffer ); |
|
661 if ( r == KErrNone ) |
|
662 { |
|
663 TRAP( r, ReadHeapInfoFreeCellsFromXferBufferL( aCells ) ); |
|
664 } |
|
665 } |
625 } |
666 } |
626 else if ( r == KErrNotSupported ) |
667 else if ( r == KErrNotSupported ) |
627 { |
668 { |
628 aInfo.SetType( TMemSpyHeapInfo::ETypeUnknown ); |
669 aInfo.SetType( TMemSpyHeapInfo::ETypeUnknown ); |
629 r = KErrNone; |
670 r = KErrNone; |
630 } |
671 } |
631 // |
672 // |
632 return r; |
673 return r; |
633 } |
674 } |
634 |
675 |
635 |
676 |
636 EXPORT_C TBool RMemSpyDriverClient::IsDebugKernel() |
677 EXPORT_C TBool RMemSpyDriverClient::IsDebugKernel() |
637 { |
678 { |
638 TBool isDebugKernel = EFalse; |
679 TBool isDebugKernel = EFalse; |
639 DoControl( EMemSpyDriverOpCodeHeapInfoGetIsDebugKernel, (TAny*) &isDebugKernel ); |
680 DoControl( EMemSpyDriverOpCodeHeapKernelDataGetIsDebugKernel, (TAny*) &isDebugKernel ); |
640 return isDebugKernel; |
681 return isDebugKernel; |
641 } |
682 } |
642 |
683 |
643 |
684 |
644 |
685 |
659 |
700 |
660 |
701 |
661 |
702 |
662 |
703 |
663 |
704 |
664 EXPORT_C TInt RMemSpyDriverClient::GetHeapData( TUint aTid, TUint32 aFreeCellChecksum, TDes8& aDest, TUint& aReadAddress, TUint& aAmountRemaining ) |
705 EXPORT_C TInt RMemSpyDriverClient::GetHeapData(TUint aTid, |
|
706 TUint32 aFreeCellChecksum, |
|
707 TDes8& aDest, |
|
708 TUint& aReadAddress, |
|
709 TUint& aAmountRemaining ) |
665 { |
710 { |
666 TMemSpyDriverInternalHeapDataParams params; |
711 TMemSpyDriverInternalHeapDataParams params; |
667 params.iTid = aTid; |
712 params.iTid = aTid; |
668 params.iRHeapVTable = RHeapVTable(); |
713 params.iRHeapVTable = RHeapVTable(); |
669 params.iDebugAllocator = DebugEUser(); |
714 params.iDebugAllocator = DebugEUser(); |
671 params.iChecksum = aFreeCellChecksum; |
716 params.iChecksum = aFreeCellChecksum; |
672 params.iRemaining = -1; |
717 params.iRemaining = -1; |
673 params.iReadAddress = 0; |
718 params.iReadAddress = 0; |
674 aDest.Zero(); |
719 aDest.Zero(); |
675 // |
720 // |
676 TInt r = DoControl( EMemSpyDriverOpCodeHeapDataGetUser, ¶ms, NULL ); |
721 TInt r = DoControl( EMemSpyDriverOpCodeHeapUserDataGetFull, ¶ms, NULL ); |
677 // |
722 // |
678 if ( r >= KErrNone ) |
723 if ( r >= KErrNone ) |
679 { |
724 { |
680 aDest.SetLength( r ); |
725 aDest.SetLength( r ); |
681 aReadAddress = params.iReadAddress; |
726 aReadAddress = params.iReadAddress; |
697 params.iChecksum = 0; |
745 params.iChecksum = 0; |
698 params.iRemaining = aAmountRemaining; |
746 params.iRemaining = aAmountRemaining; |
699 params.iReadAddress = aReadAddress; |
747 params.iReadAddress = aReadAddress; |
700 aDest.Zero(); |
748 aDest.Zero(); |
701 // |
749 // |
702 TInt r = DoControl( EMemSpyDriverOpCodeHeapDataGetUser, ¶ms, NULL ); |
750 TInt r = DoControl( EMemSpyDriverOpCodeHeapUserDataGetFull, ¶ms, NULL ); |
703 // |
751 // |
704 if ( r >= KErrNone ) |
752 if ( r >= KErrNone ) |
705 { |
753 { |
706 aDest.SetLength( r ); |
754 aDest.SetLength( r ); |
707 aReadAddress = params.iReadAddress; |
755 aReadAddress = params.iReadAddress; |
711 // |
759 // |
712 return r; |
760 return r; |
713 } |
761 } |
714 |
762 |
715 |
763 |
716 |
764 EXPORT_C TInt RMemSpyDriverClient::CopyHeapDataKernel() |
717 EXPORT_C HBufC8* RMemSpyDriverClient::GetHeapDataKernelLC( TMemSpyHeapInfo& aInfo, RArray<TMemSpyDriverFreeCell>& aFreeCells ) |
765 { |
718 { |
766 return DoControl( EMemSpyDriverOpCodeHeapKernelDataCopyHeap, NULL, NULL ); |
719 HBufC8* data = NULL; |
767 } |
720 |
768 |
721 // Going to fetch free cells via stream buffer... |
769 EXPORT_C TInt RMemSpyDriverClient::FreeHeapDataKernel() |
722 ResetStreamBuffer(); |
770 { |
723 |
771 return DoControl( EMemSpyDriverOpCodeHeapKernelDataFreeHeapCopy, NULL, NULL ); |
724 // First pass is to preallocate buffer for kernel heap, and fetch metadata and free cells |
772 } |
725 TInt sizeOrError = DoControl( EMemSpyDriverOpCodeHeapDataGetKernelInit, (TAny*) &aInfo, (TAny*) &iBuffer ); |
773 |
726 if ( sizeOrError >= KErrNone ) |
774 EXPORT_C TInt RMemSpyDriverClient::GetHeapDataKernel(TUint aTid, |
727 { |
775 TDes8& aDest, |
728 const TInt kernelHeapSize = sizeOrError; |
776 TUint& aReadAddress, |
729 if ( aInfo.Type() != TMemSpyHeapInfo::ETypeRHeap ) |
777 TUint& aAmountRemaining) |
730 { |
778 { |
731 User::Leave( KErrNotSupported ); |
779 TMemSpyDriverInternalHeapDataParams params; |
732 } |
780 params.iTid = aTid; |
733 else |
781 params.iRHeapVTable = RHeapVTable(); |
734 { |
782 params.iDebugAllocator = DebugEUser(); |
735 // Extract free cells |
783 params.iDes = &aDest; |
736 ReadHeapInfoFreeCellsFromXferBufferL( aFreeCells ); |
784 params.iChecksum = 0; |
737 |
785 params.iRemaining = -1; |
738 // It's okay to treat the heap info as an RHeap |
786 params.iReadAddress = 0; |
739 PrintHeapInfo( aInfo ); |
787 aDest.Zero(); |
740 |
788 // |
741 // Allocate data sink and do fetch |
789 TInt r = DoControl( EMemSpyDriverOpCodeHeapKernelDataGetFull, ¶ms, NULL ); |
742 data = HBufC8::NewLC( kernelHeapSize ); |
790 // |
743 TPtr8 pBuffer( data->Des() ); |
791 if ( r >= KErrNone ) |
744 |
792 { |
745 sizeOrError = DoControl( EMemSpyDriverOpCodeHeapDataGetKernelFetch, &pBuffer, NULL ); |
793 aDest.SetLength( r ); |
746 } |
794 aReadAddress = params.iReadAddress; |
747 } |
795 aAmountRemaining = params.iRemaining; |
748 |
796 r = KErrNone; |
749 User::LeaveIfError( sizeOrError ); |
797 } |
750 return data; |
798 return r; |
751 } |
799 } |
752 |
800 |
753 |
801 |
|
802 EXPORT_C TInt RMemSpyDriverClient::GetHeapDataKernelNext(TUint aTid, |
|
803 TDes8& aDest, |
|
804 TUint& aReadAddress, |
|
805 TUint& aAmountRemaining) |
|
806 { |
|
807 TMemSpyDriverInternalHeapDataParams params; |
|
808 params.iTid = aTid; |
|
809 params.iRHeapVTable = RHeapVTable(); |
|
810 params.iDebugAllocator = DebugEUser(); |
|
811 params.iDes = &aDest; |
|
812 params.iChecksum = 0; |
|
813 params.iRemaining = aAmountRemaining; |
|
814 params.iReadAddress = aReadAddress; |
|
815 aDest.Zero(); |
|
816 // |
|
817 TInt r = DoControl( EMemSpyDriverOpCodeHeapKernelDataGetFull, ¶ms, NULL ); |
|
818 // |
|
819 if ( r >= KErrNone ) |
|
820 { |
|
821 aDest.SetLength( r ); |
|
822 aReadAddress = params.iReadAddress; |
|
823 aAmountRemaining = params.iRemaining; |
|
824 r = KErrNone; |
|
825 } |
|
826 // |
|
827 return r; |
|
828 } |
754 |
829 |
755 |
830 |
756 |
831 |
757 |
832 |
758 |
833 |
790 TMemSpyDriverInternalWalkHeapParamsInit params; |
865 TMemSpyDriverInternalWalkHeapParamsInit params; |
791 params.iTid = aTid; |
866 params.iTid = aTid; |
792 params.iRHeapVTable = RHeapVTable(); |
867 params.iRHeapVTable = RHeapVTable(); |
793 params.iDebugAllocator = DebugEUser(); |
868 params.iDebugAllocator = DebugEUser(); |
794 // |
869 // |
795 const TInt r = DoControl( EMemSpyDriverOpCodeWalkHeapInit, ¶ms, NULL ); |
870 const TInt r = DoControl( EMemSpyDriverOpCodeHeapUserWalkInit, ¶ms, NULL ); |
796 return r; |
871 return r; |
797 } |
872 } |
798 |
873 |
799 |
874 |
800 EXPORT_C TInt RMemSpyDriverClient::WalkHeapNextCell( TUint aTid, TMemSpyDriverCellType& aCellType, TAny*& aCellAddress, TInt& aLength, TInt& aNestingLevel, TInt& aAllocNumber, TInt& aCellHeaderSize, TAny*& aCellPayloadAddress ) |
875 EXPORT_C TInt RMemSpyDriverClient::WalkHeapNextCell(TUint aTid, |
|
876 TMemSpyDriverCellType& aCellType, |
|
877 TAny*& aCellAddress, |
|
878 TInt& aLength, |
|
879 TInt& aNestingLevel, |
|
880 TInt& aAllocNumber, |
|
881 TInt& aCellHeaderSize, |
|
882 TAny*& aCellPayloadAddress) |
801 { |
883 { |
802 aCellType = EMemSpyDriverBadCellMask; |
884 aCellType = EMemSpyDriverBadCellMask; |
803 aCellAddress = NULL; |
885 aCellAddress = NULL; |
804 aLength = 0; |
886 aLength = 0; |
805 aNestingLevel = 0; |
887 aNestingLevel = 0; |
806 aAllocNumber = 0; |
888 aAllocNumber = 0; |
807 aCellHeaderSize = 0; |
889 aCellHeaderSize = 0; |
808 aCellPayloadAddress = NULL; |
890 aCellPayloadAddress = NULL; |
809 // |
891 // |
810 TMemSpyDriverInternalWalkHeapParamsCell params; |
892 TMemSpyDriverInternalWalkHeapParamsCell params; |
811 const TInt r = DoControl( EMemSpyDriverOpCodeWalkHeapNextCell, (TAny*) aTid, ¶ms ); |
893 const TInt r = DoControl( EMemSpyDriverOpCodeHeapUserWalkNextCell, (TAny*) aTid, ¶ms ); |
812 // |
894 // |
813 if ( r == KErrNone ) |
895 if ( r == KErrNone ) |
814 { |
896 { |
815 aCellType = (TMemSpyDriverCellType) params.iCellType; |
897 aCellType = (TMemSpyDriverCellType) params.iCellType; |
816 aCellAddress = params.iCellAddress; |
898 aCellAddress = params.iCellAddress; |
830 params.iCellAddress = aCellAddress; |
912 params.iCellAddress = aCellAddress; |
831 params.iReadLen = aReadLen; |
913 params.iReadLen = aReadLen; |
832 params.iDes = &aDest; |
914 params.iDes = &aDest; |
833 aDest.Zero(); |
915 aDest.Zero(); |
834 // |
916 // |
835 TInt r = DoControl( EMemSpyDriverOpCodeWalkHeapReadCellData, ¶ms, NULL ); |
917 TInt r = DoControl( EMemSpyDriverOpCodeHeapUserWalkReadCellData, ¶ms, NULL ); |
836 if ( r >= KErrNone ) |
918 if ( r >= KErrNone ) |
837 { |
919 { |
838 aDest.SetLength( r ); |
920 aDest.SetLength( r ); |
839 r = KErrNone; |
921 r = KErrNone; |
840 } |
922 } |
841 // |
923 // |
842 return r; |
924 return r; |
843 } |
925 } |
844 |
926 |
845 |
927 |
846 EXPORT_C TInt RMemSpyDriverClient::WalkHeapGetCellInfo( TAny*& aCellAddress, TMemSpyDriverCellType& aCellType, TInt& aLength, TInt& aNestingLevel, TInt& aAllocNumber, TInt& aCellHeaderSize, TAny*& aCellPayloadAddress ) |
928 EXPORT_C TInt RMemSpyDriverClient::WalkHeapGetCellInfo(TAny*& aCellAddress, |
|
929 TMemSpyDriverCellType& aCellType, |
|
930 TInt& aLength, |
|
931 TInt& aNestingLevel, |
|
932 TInt& aAllocNumber, |
|
933 TInt& aCellHeaderSize, |
|
934 TAny*& aCellPayloadAddress) |
847 { |
935 { |
848 aCellType = EMemSpyDriverBadCellMask; |
936 aCellType = EMemSpyDriverBadCellMask; |
849 aLength = 0; |
937 aLength = 0; |
850 aNestingLevel = 0; |
938 aNestingLevel = 0; |
851 aAllocNumber = 0; |
939 aAllocNumber = 0; |
852 aCellHeaderSize = 0; |
940 aCellHeaderSize = 0; |
853 aCellPayloadAddress = NULL; |
941 aCellPayloadAddress = NULL; |
854 // |
942 // |
855 TMemSpyDriverInternalWalkHeapParamsCell params; |
943 TMemSpyDriverInternalWalkHeapParamsCell params; |
856 const TInt r = DoControl( EMemSpyDriverOpCodeWalkHeapGetCellInfo, aCellAddress, ¶ms ); |
944 const TInt r = DoControl( EMemSpyDriverOpCodeHeapUserWalkGetCellInfo, aCellAddress, ¶ms ); |
857 // |
945 // |
858 if ( r == KErrNone ) |
946 if ( r == KErrNone ) |
859 { |
947 { |
860 aCellAddress = params.iCellAddress; |
948 aCellAddress = params.iCellAddress; |
861 aCellType = (TMemSpyDriverCellType) params.iCellType; |
949 aCellType = (TMemSpyDriverCellType) params.iCellType; |
918 // |
1006 // |
919 return r; |
1007 return r; |
920 } |
1008 } |
921 |
1009 |
922 |
1010 |
923 EXPORT_C TInt RMemSpyDriverClient::GetStackData( TUint aTid, TDes8& aDest, TUint& aAmountRemaining, TMemSpyDriverDomainType aDomain, TBool aEntireStack ) |
1011 EXPORT_C TInt RMemSpyDriverClient::GetStackData(TUint aTid, |
|
1012 TDes8& aDest, |
|
1013 TUint& aAmountRemaining, |
|
1014 TMemSpyDriverDomainType aDomain, |
|
1015 TBool aEntireStack) |
924 { |
1016 { |
925 TMemSpyDriverInternalStackDataParams params; |
1017 TMemSpyDriverInternalStackDataParams params; |
926 params.iTid = aTid; |
1018 params.iTid = aTid; |
927 params.iDes = &aDest; |
1019 params.iDes = &aDest; |
928 params.iDomain = aDomain; |
1020 params.iDomain = aDomain; |
941 // |
1033 // |
942 return r; |
1034 return r; |
943 } |
1035 } |
944 |
1036 |
945 |
1037 |
946 EXPORT_C TInt RMemSpyDriverClient::GetStackDataNext( TUint aTid, TDes8& aDest, TUint& aAmountRemaining, TMemSpyDriverDomainType aDomain, TBool aEntireStack ) |
1038 EXPORT_C TInt RMemSpyDriverClient::GetStackDataNext(TUint aTid, |
|
1039 TDes8& aDest, |
|
1040 TUint& aAmountRemaining, |
|
1041 TMemSpyDriverDomainType aDomain, |
|
1042 TBool aEntireStack ) |
947 { |
1043 { |
948 TMemSpyDriverInternalStackDataParams params; |
1044 TMemSpyDriverInternalStackDataParams params; |
949 params.iTid = aTid; |
1045 params.iTid = aTid; |
950 params.iDes = &aDest; |
1046 params.iDes = &aDest; |
951 params.iDomain = aDomain; |
1047 params.iDomain = aDomain; |
1094 const TInt error = DoControl( EMemSpyDriverOpCodeProcessInspectClose, (TAny*) aPid ); |
1190 const TInt error = DoControl( EMemSpyDriverOpCodeProcessInspectClose, (TAny*) aPid ); |
1095 return error; |
1191 return error; |
1096 } |
1192 } |
1097 |
1193 |
1098 |
1194 |
1099 EXPORT_C void RMemSpyDriverClient::ProcessInspectionRequestChanges( TUint aPid, TRequestStatus& aStatus, TMemSpyDriverProcessInspectionInfo& aInfo ) |
1195 EXPORT_C void RMemSpyDriverClient::ProcessInspectionRequestChanges(TUint aPid, |
|
1196 TRequestStatus& aStatus, |
|
1197 TMemSpyDriverProcessInspectionInfo& aInfo ) |
1100 { |
1198 { |
1101 aInfo.iProcessId = aPid; |
1199 aInfo.iProcessId = aPid; |
1102 aStatus = KRequestPending; |
1200 aStatus = KRequestPending; |
1103 const TInt err = DoControl( EMemSpyDriverOpCodeProcessInspectRequestChanges, (TAny*) &aStatus, (TAny*) &aInfo ); |
1201 const TInt err = DoControl( EMemSpyDriverOpCodeProcessInspectRequestChanges, (TAny*) &aStatus, (TAny*) &aInfo ); |
1104 if ( err != KErrNone ) |
1202 if ( err != KErrNone ) |
1148 |
1246 |
1149 |
1247 |
1150 |
1248 |
1151 |
1249 |
1152 |
1250 |
1153 EXPORT_C TInt RMemSpyDriverClient::GetContainerHandles( TMemSpyDriverContainerType aContainer, TAny** aHandleArray, TInt& aHandleCount ) |
1251 EXPORT_C TInt RMemSpyDriverClient::GetContainerHandles(TMemSpyDriverContainerType aContainer, |
|
1252 TAny** aHandleArray, |
|
1253 TInt& aHandleCount) |
1154 { |
1254 { |
1155 TMemSpyDriverInternalContainerHandleParams params; |
1255 TMemSpyDriverInternalContainerHandleParams params; |
1156 params.iTidOrPid = KMemSpyDriverEnumerateContainerHandles; |
1256 params.iTidOrPid = KMemSpyDriverEnumerateContainerHandles; |
1157 params.iContainer = aContainer; |
1257 params.iContainer = aContainer; |
1158 params.iHandles = aHandleArray; |
1258 params.iHandles = aHandleArray; |
1164 // |
1264 // |
1165 return DoControl( EMemSpyDriverOpCodeContainersGetHandles, ¶ms, NULL ); |
1265 return DoControl( EMemSpyDriverOpCodeContainersGetHandles, ¶ms, NULL ); |
1166 } |
1266 } |
1167 |
1267 |
1168 |
1268 |
1169 EXPORT_C TInt RMemSpyDriverClient::GetThreadHandlesByType( TInt aTid, TMemSpyDriverContainerType aType, TAny** aHandleArray, TInt& aHandleCount ) |
1269 EXPORT_C TInt RMemSpyDriverClient::GetThreadHandlesByType(TInt aTid, |
|
1270 TMemSpyDriverContainerType aType, |
|
1271 TAny** aHandleArray, |
|
1272 TInt& aHandleCount) |
1170 { |
1273 { |
1171 TMemSpyDriverInternalContainerHandleParams params; |
1274 TMemSpyDriverInternalContainerHandleParams params; |
1172 params.iTidOrPid = aTid; |
1275 params.iTidOrPid = aTid; |
1173 params.iContainer = aType; |
1276 params.iContainer = aType; |
1174 params.iHandles = aHandleArray; |
1277 params.iHandles = aHandleArray; |
1180 // |
1283 // |
1181 return DoControl( EMemSpyDriverOpCodeContainersGetHandles, ¶ms, NULL ); |
1284 return DoControl( EMemSpyDriverOpCodeContainersGetHandles, ¶ms, NULL ); |
1182 } |
1285 } |
1183 |
1286 |
1184 |
1287 |
1185 EXPORT_C TInt RMemSpyDriverClient::GetProcessHandlesByType( TInt aPid, TMemSpyDriverContainerType aType, TAny** aHandleArray, TInt& aHandleCount ) |
1288 EXPORT_C TInt RMemSpyDriverClient::GetProcessHandlesByType(TInt aPid, |
|
1289 TMemSpyDriverContainerType aType, |
|
1290 TAny** aHandleArray, |
|
1291 TInt& aHandleCount) |
1186 { |
1292 { |
1187 TMemSpyDriverInternalContainerHandleParams params; |
1293 TMemSpyDriverInternalContainerHandleParams params; |
1188 params.iTidOrPid = aPid; |
1294 params.iTidOrPid = aPid; |
1189 params.iContainer = aType; |
1295 params.iContainer = aType; |
1190 params.iHandles = aHandleArray; |
1296 params.iHandles = aHandleArray; |
1196 // |
1302 // |
1197 return DoControl( EMemSpyDriverOpCodeContainersGetHandles, ¶ms, NULL ); |
1303 return DoControl( EMemSpyDriverOpCodeContainersGetHandles, ¶ms, NULL ); |
1198 } |
1304 } |
1199 |
1305 |
1200 |
1306 |
1201 EXPORT_C TInt RMemSpyDriverClient::GetGenericHandleInfo( TInt aTid, TMemSpyDriverContainerType aType, TAny* aHandle, TMemSpyDriverHandleInfoGeneric& aParams ) |
1307 EXPORT_C TInt RMemSpyDriverClient::GetGenericHandleInfo(TInt aTid, |
|
1308 TMemSpyDriverContainerType aType, |
|
1309 TAny* aHandle, |
|
1310 TMemSpyDriverHandleInfoGeneric& aParams) |
1202 { |
1311 { |
1203 aParams.iType = aType; |
1312 aParams.iType = aType; |
1204 aParams.iHandle = aHandle; |
1313 aParams.iHandle = aHandle; |
1205 // |
1314 // |
1206 const TInt r = DoControl( EMemSpyDriverOpCodeContainersGetHandleInfo, (TAny*) aTid, &aParams ); |
1315 const TInt r = DoControl( EMemSpyDriverOpCodeContainersGetHandleInfo, (TAny*) aTid, &aParams ); |
1237 const TInt r = DoControl( EMemSpyDriverOpCodeContainersGetPAndSInfo, (TAny*) aHandle, &aInfo ); |
1346 const TInt r = DoControl( EMemSpyDriverOpCodeContainersGetPAndSInfo, (TAny*) aHandle, &aInfo ); |
1238 return r; |
1347 return r; |
1239 } |
1348 } |
1240 |
1349 |
1241 |
1350 |
1242 EXPORT_C TInt RMemSpyDriverClient::GetCondVarSuspendedThreads( TAny* aCondVarHandle, TAny** aThreadHandleArray, TInt& aThreadCount ) |
1351 EXPORT_C TInt RMemSpyDriverClient::GetCondVarSuspendedThreads(TAny* aCondVarHandle, |
|
1352 TAny** aThreadHandleArray, |
|
1353 TInt& aThreadCount) |
1243 { |
1354 { |
1244 TMemSpyDriverInternalCondVarSuspendedThreadParams params; |
1355 TMemSpyDriverInternalCondVarSuspendedThreadParams params; |
1245 params.iCondVarHandle = aCondVarHandle; |
1356 params.iCondVarHandle = aCondVarHandle; |
1246 params.iThrHandles = aThreadHandleArray; |
1357 params.iThrHandles = aThreadHandleArray; |
1247 params.iThrCountPtr = &aThreadCount; |
1358 params.iThrCountPtr = &aThreadCount; |
1251 // |
1362 // |
1252 return DoControl( EMemSpyDriverOpCodeContainersGetCondVarSuspendedThreads, ¶ms, NULL ); |
1363 return DoControl( EMemSpyDriverOpCodeContainersGetCondVarSuspendedThreads, ¶ms, NULL ); |
1253 } |
1364 } |
1254 |
1365 |
1255 |
1366 |
1256 EXPORT_C TInt RMemSpyDriverClient::GetCondVarSuspendedThreadInfo( TAny* aHandle, TMemSpyDriverCondVarSuspendedThreadInfo& aParams ) |
1367 EXPORT_C TInt RMemSpyDriverClient::GetCondVarSuspendedThreadInfo(TAny* aHandle, |
|
1368 TMemSpyDriverCondVarSuspendedThreadInfo& aParams) |
1257 { |
1369 { |
1258 return DoControl( EMemSpyDriverOpCodeContainersGetCondVarSuspendedThreadInfo, aHandle, &aParams ); |
1370 return DoControl( EMemSpyDriverOpCodeContainersGetCondVarSuspendedThreadInfo, aHandle, &aParams ); |
1259 } |
1371 } |
1260 |
1372 |
1261 |
1373 |
1272 |
1384 |
1273 |
1385 |
1274 |
1386 |
1275 |
1387 |
1276 |
1388 |
1277 EXPORT_C TInt RMemSpyDriverClient::GetServerSessionHandles( TAny* aServerHandle, TAny** aSessionHandleArray, TInt& aSessionHandleCount ) |
1389 EXPORT_C TInt RMemSpyDriverClient::GetServerSessionHandles(TAny* aServerHandle, |
|
1390 TAny** aSessionHandleArray, |
|
1391 TInt& aSessionHandleCount) |
1278 { |
1392 { |
1279 TMemSpyDriverInternalServerSessionHandleParams params; |
1393 TMemSpyDriverInternalServerSessionHandleParams params; |
1280 params.iServerHandle = aServerHandle; |
1394 params.iServerHandle = aServerHandle; |
1281 params.iSessionHandles = aSessionHandleArray; |
1395 params.iSessionHandles = aSessionHandleArray; |
1282 params.iSessionCountPtr = &aSessionHandleCount; |
1396 params.iSessionCountPtr = &aSessionHandleCount; |
1286 // |
1400 // |
1287 return DoControl( EMemSpyDriverOpCodeClientServerGetServerSessionHandles, ¶ms, NULL ); |
1401 return DoControl( EMemSpyDriverOpCodeClientServerGetServerSessionHandles, ¶ms, NULL ); |
1288 } |
1402 } |
1289 |
1403 |
1290 |
1404 |
1291 EXPORT_C TInt RMemSpyDriverClient::GetServerSessionInfo( TAny* aSessionHandle, TMemSpyDriverServerSessionInfo& aParams ) |
1405 EXPORT_C TInt RMemSpyDriverClient::GetServerSessionInfo(TAny* aSessionHandle, |
|
1406 TMemSpyDriverServerSessionInfo& aParams) |
1292 { |
1407 { |
1293 return DoControl( EMemSpyDriverOpCodeClientServerGetServerSessionInfo, aSessionHandle, &aParams ); |
1408 return DoControl( EMemSpyDriverOpCodeClientServerGetServerSessionInfo, aSessionHandle, &aParams ); |
1294 } |
1409 } |
1295 |
1410 |
1296 |
1411 |