示例#1
0
 public EventSource(Controller controller, string sourceName, UIntPtr storageHandle)
 {
     SourceName     = sourceName;
     Storage        = EventingStorage.CreateStorageFromHandle(storageHandle);
     ControlFlags   = ENABLE_ALL_MASK;
     HostController = controller;
 }
示例#2
0
        //  Storage registration routines

        public bool RegisterStorage(EventingStorage Storage)
        {
            Lock.AcquireMutex();
            bool success = RegisterStorageImpl(Storage.GetHandle());

            Lock.ReleaseMutex();
            return(success);
        }
示例#3
0
 public void UnRegisterStorage(EventingStorage Storage)
 {
     if (!Controller.Finalized)
     {
         Lock.AcquireMutex();
         UnRegisterStorageImpl(Storage.GetHandle());
         Lock.ReleaseMutex();
     }
 }
示例#4
0
        public static ControllerLogger Create(string sourceName, EventingStorage storage)
        {
            ControllerLogger Logger = new ControllerLogger(sourceName,
                                                           storage,
                                                           CAPTURE_STACK_TRACE | ENABLE_ALL_MASK);

            if (Logger != null)
            {
                Logger.Register();
            }

            return(Logger);
        }
示例#5
0
 public EventSource(string sourceName, EventingStorage storage, uint controlFlags)
 {
     SourceName   = sourceName;
     Storage      = storage;
     ControlFlags = controlFlags;
     if (storage != null)
     {
         HostController = storage.GetController();
     }
     else
     {
         HostController = Controller.GetLocalController();
     }
 }
示例#6
0
        internal override void Initialize()
        {
            if (KernelControllerObject != null)
            {
                //  Already initialized

                return;
            }

            base.Initialize();
            ProcessContext.Initialize();

            GeneralPurposeStorage = EventingStorage.CreateLocalStorage(QualityOfService.RecyclableEvents,
                                                                       BUFFER_EXPANSION_SIZE);

            KernelControllerObject = this;
        }
示例#7
0
        public bool Initialize(EventingStorage storage,
                               bool forward)
        {
            if (EntryBuffer == null)
            {
                EntryBuffer = new QueryBuffer(256);
                if ((EntryBuffer == null) || (EntryBuffer.GetBuffer() == null))
                {
                    return(false);
                }
            }

            //  Cleanup for the previous states.

            if (QueryHandle != 0)
            {
                QueryStorage.DeleteQueryView(QueryHandle);
                QueryHandle  = 0;
                QueryStorage = null;
            }

            //  Initialize the new query states

            QueryStorage = storage;

            if (QueryStorage == null)
            {
                return(false);
            }

            QueryHandle = QueryStorage.CreateQueryView(forward);

            if (QueryHandle == 0)
            {
                QueryStorage = null;

                return(false);
            }

            return(true);
        }
示例#8
0
        public static SystemAllocationLogger Create(string sourceName)
        {
            EventingStorage storage = EventingStorage.CreateLocalStorage(QualityOfService.RecyclableEvents,
                                                                         DefaultLogSize);

            if (storage == null)
            {
                return(null);
            }

            SystemAllocationLogger Logger = new SystemAllocationLogger(sourceName,
                                                                       storage,
                                                                       ENABLE_ALL_MASK);

            if (Logger != null)
            {
                Logger.Register();
            }

            return(Logger);
        }
示例#9
0
        public static ProcessorLogger Create(string sourceName)
        {
            EventingStorage storage = EventingStorage.CreateLocalStorage(QualityOfService.RecyclableEvents,
                                                                         DefaultProcessorLogSize);

            if (storage == null)
            {
                return(null);
            }

            ProcessorLogger Logger = new ProcessorLogger(sourceName,
                                                         storage,
                                                         CAPTURE_STACK_TRACE | ENABLE_ALL_MASK);

            if (Logger != null)
            {
                Logger.Register();
            }

            return(Logger);
        }
示例#10
0
        public static SamplingProfiler Create(string sourceName, int maxStackSize, uint storageSize)
        {
            EventingStorage storage = EventingStorage.CreateLocalStorage(QualityOfService.RecyclableEvents,
                                                                         storageSize);

            if (storage == null)
            {
                return(null);
            }

            SamplingProfiler Logger = new SamplingProfiler(sourceName,
                                                           maxStackSize,
                                                           storage,
                                                           ENABLE_ALL_MASK);

            if (Logger != null)
            {
                Logger.Register();
            }

            return(Logger);
        }
示例#11
0
 SystemAllocationLogger(string sourceName, EventingStorage storage, uint controlFlags)
     : base(sourceName, storage, controlFlags)
 {
 }
示例#12
0
 SamplingProfiler(string sourceName, int maxStackSize, EventingStorage storage, uint controlFlags)
     : base(sourceName, storage, controlFlags)
 {
     MaxStackSize = maxStackSize;
     StackTrace   = new UIntPtr[maxStackSize];
 }
示例#13
0
 ProcessorLogger(string sourceName, EventingStorage storage, uint controlFlags)
     : base(sourceName, storage, controlFlags)
 {
 }
示例#14
0
        //  Public methods

        //  Private methods

        internal override void Initialize()
        {
            base.Initialize();

            EventTable         = new Hashtable();
            SourcesLookupTable = new Hashtable();
            SourcesHandleTable = new Hashtable();

            UIntPtr RepositoryStorageHandle = FetchLocalStorage();

            if (RepositoryStorageHandle != 0)
            {
                TypesRepository = EventingStorage.CreateStorageFromHandle(RepositoryStorageHandle);

                //  Fetch now the existing source list created before initializing the controller

                int        currentSize = 20;
                UIntPtr [] sourceArray = new UIntPtr[currentSize];

                if (sourceArray != null)
                {
                    unsafe
                    {
                        fixed(UIntPtr *ptr = sourceArray)
                        {
                            int sourceCount = QuerySystemSources(ptr, (ushort)currentSize);

                            while (sourceCount > currentSize)
                            {
                                sourceArray = new UIntPtr[sourceCount];
                                sourceCount = QuerySystemSources(ptr, (ushort)currentSize);
                            }

                            for (int i = 0; i < sourceCount; i++)
                            {
                                UIntPtr sourceHandle  = sourceArray[i];
                                UIntPtr storageHandle = 0;
                                string  bufferName    = "";

                                if (GetNativeSourceName(sourceHandle, ref storageHandle, ref bufferName))
                                {
                                    EventSource source = new EventSource(this, bufferName, storageHandle);

                                    if (source != null)
                                    {
                                        source.Register();
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                TypesRepository = EventingStorage.CreateLocalStorage(QualityOfService.PermanentEvents,
                                                                     BUFFER_EXPANSION_SIZE);
                SetRepositoryStorage(TypesRepository.GetHandle());
            }

            string sourceName = "ControllerLog";

#if SINGULARITY_KERNEL
            sourceName = sourceName + "{kernel}";
#else
            unsafe {
                int    argMaxLen = ProcessService.GetStartupArg(0, null, 0);
                char[] argArray  = new char [argMaxLen];


                fixed(char *argptr = &argArray[0])
                {
                    int len = ProcessService.GetStartupArg(0,
                                                           argptr,
                                                           argArray.Length);

                    sourceName = sourceName + "{" + String.StringCTOR(argptr, 0, len) + "}";
                    sourceName = sourceName + "(PID:" + ProcessService.GetCurrentProcessId() + ")";
                }
            }
#endif

            InternalSource = ControllerLogger.Create(sourceName, TypesRepository);
        }
示例#15
0
        public virtual void EnumerateActiveSources(QuerySourceDelegate sourceDelegate,
                                                   ActiveSourceEntryDelegate activeEntryDelegate,
                                                   QueryEntryDelegate entryDelegate,
                                                   ushort maxEntrySize,
                                                   ref EnumerationContext context)
        {
            if (maxEntrySize == 0)
            {
                maxEntrySize = DefaultEntrySize;
            }

            //  Create a temporary buffer to store the temporary query information

            QueryBuffer entryBuffer = new QueryBuffer(maxEntrySize);

            if ((entryBuffer == null) || (sourceDelegate == null))
            {
                return;
            }

            //  Prepare to query the controller for the source list. We just pick up an number
            //  that would represent the limit for most common cases as the initial guess.

            int currentSize = 100;

            UIntPtr [] sourceArray = new UIntPtr[currentSize];

            if (sourceArray != null)
            {
                //  Query the controller for the actual source list

                int sourceCount = QuerySourcesList(sourceArray, currentSize);

                //
                //  The array was not large enough, attempt again with the new size

                while (sourceCount > currentSize)
                {
                    sourceArray = new UIntPtr[sourceCount];
                    sourceCount = QuerySourcesList(sourceArray, currentSize);
                }

                //
                //  We sucessfully received an array of entries. We walk them and build the
                //  required information
                //

                for (int i = 0; i < sourceCount; i++)
                {
                    UIntPtr sourceHandle  = sourceArray[i];
                    UIntPtr storageHandle = 0;
                    UIntPtr eventType     = 0;
                    UInt16  count         = 0;
                    string  bufferName    = "";

                    if (GetSourceInformation(sourceHandle,
                                             ref storageHandle,
                                             ref eventType,
                                             ref count,
                                             ref bufferName))
                    {
                        if (storageHandle == 0)
                        {
                            //
                            //  This is an active source. The eventing has no information
                            //  about the storage, it has instead information about the
                            //  types of events handled by this source
                            //

                            EventDescriptor descriptor = QuerySession.GetEventDescriptor(this,
                                                                                         eventType);

                            if (descriptor != null)
                            {
                                //  The source is valid, call the delegate with the appropriate
                                //  arguments filled in
                                // TODO: Also retrieve the control flags status


                                if (!sourceDelegate(sourceHandle,
                                                    storageHandle,
                                                    eventType,
                                                    count,
                                                    bufferName,
                                                    descriptor,
                                                    ref context))
                                {
                                    break;
                                }

                                if (entryDelegate != null)
                                {
                                    //  The caller also provided an entry delegate. We need in that
                                    //  case to also enumerate all entries from the active source

                                    for (int index = 0; index < count; index++)
                                    {
                                        if (!QueryActiveEntry(sourceHandle,
                                                              index,
                                                              ref entryBuffer))
                                        {
                                            break;
                                        }

                                        activeEntryDelegate(sourceHandle,
                                                            index,
                                                            descriptor,
                                                            entryBuffer,
                                                            ref context);
                                    }
                                }
                            }
                        }
                        else
                        {
                            //  This source has an associated storage. Enumerate the entries from
                            //  the storage
                            // TODO: we might also want to filter the sources inside the storage
                            // since multiple sources can share the same storage

                            if (!sourceDelegate(sourceHandle,
                                                storageHandle,
                                                eventType,
                                                count,
                                                bufferName,
                                                null,
                                                ref context))
                            {
                                break;
                            }

                            EventingStorage storage = OpenStorage(storageHandle);

                            if (storage != null)
                            {
                                // Instantiate a query session for the storage and
                                // enumerate the entries passing the provided delegate

                                QuerySession query = new QuerySession();

                                if ((query != null) && (context != null) &&
                                    query.Initialize(storage, false))
                                {
                                    query.EnumerateEntries(entryDelegate, ref context);
                                }
                            }
                        }
                    }
                }
            }
        }