Win32: Comment obtenir le processus/thread qui possède un mutex?

Question

Je travaille sur une application dont une seule instance doit exister à un moment donné. Il existe plusieurs possibilités pour y parvenir:

• Vérifiez les processus en cours d'exécution pour un correspondant à notre nom EXE (peu fiable)
• Trouver la fenêtre principale (peu fiable, et je n'ai pas toujours une fenêtre principale)
• Créer un mutex avec un nom unique (GUID)

L'option mutex me semble la plus fiable et élégante.

Toutefois, avant la fin de ma seconde instance, je souhaite publier un message sur l'instance en cours d'exécution. Pour cela, j'ai besoin d'un handle pour le thread (ou le processus) qui possède le mutex.

Cependant, il ne semble pas y avoir de fonction API pour obtenir le créateur/propriétaire d'un mutex donné. Suis-je juste en train de le négliger? Y a-t-il un autre moyen d'accéder à ce fil/processus? Y a-t-il un autre moyen d'y parvenir?

Mise à jour: This guy simplement diffuser un message à tous les processus en cours d'exécution. Je suppose que c'est possible, mais je ne l'aime pas vraiment ...

Answer 1

Je ne pense pas Il existe un moyen trivial de résoudre le propriétaire actuel d'un Mutex, mais le processus qui le possède peut créer d'autres éléments secondaires dont la durée de vie est liée à celui-ci. Il existe de nombreux mécanismes qui permettent de rappeler des processus croisés sans avoir de fenêtre principale.

1. Enregistrez un objet dans la table COM Running Object. Les clients qui ne sont pas en mesure de prendre possession du Mutex peuvent rechercher le propriétaire via le ROT et rappeler le propriétaire. Un fichier Moniker devrait être approprié pour l'enregistrement ici.
2. Créez un morceau de mémoire partagée contenant les détails d'emplacement pour le processus propriétaire. De là, écrivez dans le tampon le handle de processus et le handle de thread d'un thread pouvant recevoir des messages Windows, puis utilisez PostThreadMessage() pour envoyer une notification. Tout autre processus concurrent peut ouvrir la mémoire partagée en lecture seule pour déterminer où envoyer un message Windows.
3. Écoutez le processus du propriétaire sur un socket ou un tube nommé. Probablement trop et pas un bon match pour vos besoins.
4. Utilisez un fichier partagé avec verrouillage. Je ne suis pas friand de ceci parce que le propriétaire devra interroger, et il ne manipulera pas gracieusement N potentiels d'autres processus qui pourraient essayer de contacter le propriétaire en même temps.

Voici les liens de référence pour les deux premières options.

1. IRunningObjectTable @ MSDN, File Monikers @ MSDN
2. Creating Named Shared Memory @ MSDN

Answer 2

Je n'ai jamais vraiment compris la raison derrière l'utilisation d'un Mutex qui n'a pas de capacité de signalisation. Je créerais plutôt un événement (using CreateEvent) qui a les mêmes propriétés que créer un mutex (c.-à-d. Avec un nom qu'il peut retourner que l'objet existait déjà) mais vous pouvez placer l'indicateur d'événement dans le nouveau processus, aussi longtemps que l'original le processus attend sur l'indicateur d'événement qu'il peut être averti quand il doit se réveiller.

Answer 3

Vous pouvez toujours le faire de la manière UNIX et créer un fichier "pid", en plaçant l'ID de processus de l'instance en cours d'exécution dans ce fichier. Ensuite, demandez à l'application de supprimer le fichier à sa fermeture.

Lorsqu'une nouvelle instance démarre, il doit vérifier que le processus dans le fichier PID est en fait vivant aussi bien (dans le cas où l'application se termine anormalement et le fichier ne soit pas supprimé)

Answer 4

Cela devrait vous aider à démarrer sur la demande initiale pour obtenir un processus qui est propriétaire d'un mutex.

Il est en C#, mais les appels Win32 sont les mêmes.

class HandleInfo 
{ 
    [DllImport("ntdll.dll", CharSet = CharSet.Auto)] 
    public static extern uint NtQuerySystemInformation(int SystemInformationClass, IntPtr SystemInformation, int SystemInformationLength, out int ReturnLength); 

    [DllImport("kernel32.dll", SetLastError = true)] 
    internal static extern IntPtr VirtualAlloc(IntPtr address, uint numBytes, uint commitOrReserve, uint pageProtectionMode); 

    [DllImport("kernel32.dll", SetLastError=true)] 
    internal static extern bool VirtualFree(IntPtr address, uint numBytes, uint pageFreeMode); 

    [StructLayout(LayoutKind.Sequential)] 
    public struct SYSTEM_HANDLE_INFORMATION 
    { 
     public int ProcessId; 
     public byte ObjectTypeNumber; 
     public byte Flags; // 1 = PROTECT_FROM_CLOSE, 2 = INHERIT 
     public short Handle; 
     public int Object; 
     public int GrantedAccess; 
    } 

    static uint MEM_COMMIT = 0x1000; 
    static uint PAGE_READWRITE = 0x04; 
    static uint MEM_DECOMMIT = 0x4000; 
    static int SystemHandleInformation = 16; 
    static uint STATUS_INFO_LENGTH_MISMATCH = 0xC0000004; 

    public HandleInfo() 
    { 
     IntPtr memptr = VirtualAlloc(IntPtr.Zero, 100, MEM_COMMIT, PAGE_READWRITE); 

     int returnLength = 0; 
     bool success = false; 

     uint result = NtQuerySystemInformation(SystemHandleInformation, memptr, 100, out returnLength); 
     if (result == STATUS_INFO_LENGTH_MISMATCH) 
     { 
      success = VirtualFree(memptr, 0, MEM_DECOMMIT); 
      memptr = VirtualAlloc(IntPtr.Zero, (uint)(returnLength + 256), MEM_COMMIT, PAGE_READWRITE); 
      result = NtQuerySystemInformation(SystemHandleInformation, memptr, returnLength, out returnLength); 
     } 

     int handleCount = Marshal.ReadInt32(memptr); 
     SYSTEM_HANDLE_INFORMATION[] returnHandles = new SYSTEM_HANDLE_INFORMATION[handleCount]; 

     using (StreamWriter sw = new StreamWriter(@"C:\NtQueryDbg.txt")) 
     { 
      sw.WriteLine("@ Offset\tProcess Id\tHandle Id\tHandleType"); 
      for (int i = 0; i < handleCount; i++) 
      { 
       SYSTEM_HANDLE_INFORMATION thisHandle = (SYSTEM_HANDLE_INFORMATION)Marshal.PtrToStructure(
        new IntPtr(memptr.ToInt32() + 4 + i * Marshal.SizeOf(typeof(SYSTEM_HANDLE_INFORMATION))), 
        typeof(SYSTEM_HANDLE_INFORMATION)); 
       sw.WriteLine("{0}\t{1}\t{2}\t{3}", i.ToString(), thisHandle.ProcessId.ToString(), thisHandle.Handle.ToString(), thisHandle.ObjectTypeNumber.ToString()); 
      } 
     } 

     success = VirtualFree(memptr, 0, MEM_DECOMMIT); 
    } 
} 

Answer 5

Créer une zone de mémoire partagée avec le nom fixe:

http://msdn.microsoft.com/en-us/library/aa366551%28VS.85%29.aspx

Ensuite, vous pouvez mettre une structure que vous aimez à l'intérieur, y compris l'ID de processus, HWND etc.

Il existe une option portable: créer une socket sur un port (avec un nombre fixe) et attendre (accepter) sur elle. La deuxième instance de l'application échouera puisque le port est déjà pris. Ensuite, la seconde instance peut se connecter au socket de l'instance principale et envoyer toute information désirée. Je souhaite que cela aide ...