Suite

Quelque chose lié à Python provoque un blocage d'ArcGIS for Desktop ?


Problème: ArcMap 10.3 se bloque sur le bureau chaque fois que j'utilise une fonction liée à Python (boîtes à outils, calculateur de champ, etc.)

Comment j'en suis arrivé là : J'essayais de me familiariser avec la programmation Python et j'ai choisi d'utiliser le guide Learn Python The Hard Way.
Cela impliquait le téléchargement, l'installation de Python et la configuration de votre environnement à l'aide de Powershell.
Je pense que cela a causé quelques problèmes car il y avait déjà une installation de Python en vigueur à partir de l'installation d'ArcGIS. Il y avait déjà un dossier "Python27" sur mon disque dur principal.

Question: Comment demander à mon ArcMap de rechercher dans le dossier "Python27ArcGIS10.3" pour Python ? Je préférerais éviter de réinstaller entièrement ArcGIS.

Captures d'écran pour la réflexion :

^ D'après les recherches initiales, j'ai découvert que je devrais avoir une sorte de répertoire Python entré dans ces champs, mais je ne suis pas sûr de ce qu'il faut spécifiquement y entrer.


Pour résoudre le problème, j'ai effectué les opérations suivantes :

  • Installations/instances supplémentaires supprimées de Python en dehors de mon dossier ArcGIS10.3.
  • Réinitialisez mon environnement en suivant les étapes de "Apprendre Python à la dure" en lui disant de regarder dans "Python27ArcGIS10.3"
  • "Programme de réparation" utilisé à partir de l'application d'installation dans le dossier principal pour ArcGISDesktop

Les choses semblent désormais stables et opérationnelles.


PyQt5 - Les changements de Palette/StyleSheet font planter le programme en utilisant eventFilter

J'ai essayé d'imiter la calculatrice de Windows en utilisant PyQt5 . J'ai atteint un point où je devais changer la couleur du texte qui se trouve sur le QLabel que j'utilise comme bordure de fenêtre personnalisée (pour permettre des choses telles que la transparence).

J'ai commencé à expérimenter avec des choses telles que QEvent et eventFilter et à utiliser des méthodes telles que isActiveWindow pour essayer de basculer entre les nuances de noir et entre les couleurs transparentes et non transparentes.

Ce faisant, j'ai réussi à arriver à un stade où l'arrière-plan change parfaitement, mais au moment où j'essaie d'ajouter le QLabel/Text dans le mélange, le programme plante à différents moments. Au moment de l'écriture, je n'ai pas réussi à comprendre où ou pourquoi et l'utilisation de la console imprime simplement "Process terminé avec le code de sortie -1073740791 (0xC0000409)".

De plus, je n'ai rien trouvé d'évident pour mes connaissances et mon expérience actuelles quant à la raison pour laquelle cela se produit. Jusqu'à présent, YouTube, Google et le contenu existant de StackOverflow m'ont laissé tomber. :(

Veuillez prendre en considération que je suis extrêmement nouveau dans la programmation, Python et encore plus PyQt5.


Si le nom de fichier est contrôlé par l'utilisateur, vous pourriez vous ouvrir à des vulnérabilités (par exemple, un attaquant pourrait essayer de lire les fichiers de configuration avec le mot de passe de la base de données). Mais le simple fait d'ouvrir un descripteur de fichier pour un fichier téléchargé ne peut pas faire grand-chose.

Peut-être que si le mécanisme sous-jacent essayait de lire l'intégralité du fichier à des fins de mise en mémoire tampon, il pourrait remplir la RAM et faire planter le processus, mais Python ne le fait pas : pour lire l'intégralité du fichier, vous devez d'abord appeler f.read( ) -- mais c'est exactement ce que vous faites avec, et non pas l'ouverture du fichier. Seule l'ouverture du fichier est inoffensive.

Les systèmes d'exploitation ont généralement un nombre limité de fichiers qu'ils peuvent ouvrir à la fois (en particulier, un nombre limité de descripteurs de fichiers ou de fd s dans les systèmes de type Unix, ou HANDLE s dans Windows). Si vous autorisez les utilisateurs à en ouvrir un nombre arbitraire sans les fermer, il pourrait être possible d'épuiser cette limite, ce qui empêcherait le système d'exploitation d'ouvrir plus de fichiers et provoquerait probablement un mauvais comportement ou même un blocage. Il serait cependant difficile de l'exploiter pour autre chose qu'un déni de service. En outre, les programmes peuvent avoir des quotas (inférieurs à la limite du système) du nombre de fichiers qu'ils peuvent ouvrir, donc un seul programme qui se comporte mal ne pourrait pas faire trop, et tous les fichiers d'un processus sont libérés lorsque le processus se termine si normalement c'est facile assez pour restaurer la fonction (en effet, la plupart des programmes se bloqueraient avant longtemps).

Pourtant, si vous laissez les gens dire à votre serveur d'ouvrir un fichier, ce serait une bonne idée d'avoir une limite sur le nombre pouvant être ouvert à la fois, et de fermer le fichier (automatiquement, si l'utilisateur ne le demande pas se produire en premier) après le moins de temps possible.

Un autre risque pourrait être l'ouverture de connexions réseau, en fonction du système d'exploitation sur lequel vous exécutez et des types de chemin qu'il accepte. Par exemple, si le système accepte les chemins de style réseau Windows ( serversharepath ofile ) ou les chemins SMB (le protocole réseau Windows, implémenté sur Unix-like dans la boîte à outils Samba) ( smb://server/ share/path ), ou d'autres moyens d'accéder à tout type de système de fichiers réseau qui n'est pas encore monté (ou "mappé" pour utiliser l'ancien terme Windows) sur le système de fichiers local, ce qui pourrait amener votre serveur à ouvrir une connexion réseau à la box d'un attaquant et éventuellement tenter de s'authentifier. Cela pourrait révéler des informations sur le serveur et fournir un vecteur aux attaquants pour tenter de compromettre le serveur via des réponses malveillantes.

Ainsi, vous devez également restreindre les noms de fichiers à des éléments dont vous pouvez être sûr qu'il ne s'agit pas de chemins distants. En général, vous devriez probablement éviter de laisser les chemins être spécifiés, n'autoriser que les noms de fichiers. Ce sont les deux seuls risques auxquels je peux penser, cependant. Sinon, c'est assez sûr.


VS Code provoque 17.10, 18.04 au hasard et complètement geler

Lisez s'il vous plaît: Voir le dernier bit. Je ne pense pas que ce soit un problème lié à Ubuntu, mais plutôt VS Code.

Récemment, sous 17.10 et 18.04 (je viens de mettre à jour aujourd'hui), Ubuntu se bloquera de manière aléatoire et complète. Je ne peux pas déplacer le curseur ou utiliser le clavier. Naturellement, j'ai essayé de passer à une session TTY sans succès. A chaque fois, je dois recourir à SysRq + R E I S U B , ce qui n'est (évidemment) pas préféré.

J'ai essayé de changer de pilote graphique, en supposant que ce soit cela. J'utilisais à l'origine le pilote open source nVidia et je suis passé au propriétaire en vain. J'utilise actuellement le pilote open source.

Tout ce que j'ai généralement ouvert est Firefox (pas une tonne d'onglets chargé) et VS Code, avec au plus quelques fichiers et un terminal ouvert.

Mise à jour : les journaux du système n'affichent aucune indication de n'importe quoi du tout se passe, sans parler de quelque chose de mal. Je ne sais pas si cela est lié, mais parfois (et surtout après le démarrage) les programmes prennent beaucoup de temps (> 5 à 10 secondes), même les programmes en ligne de commande.

Encore une mise à jour ! — Même avec toutes les extensions GNOME désactivées, il plantait toujours. J'ai essayé XFCE, qui plantait toujours.

Résumé: Ubuntu se bloque complètement à des moments apparemment aléatoires, ne laissant aucune trace dans les journaux, et n'est lié à aucun environnement de bureau spécifique ou à des extensions GNOME.

Mise à jour (probablement finale): je suis convaincu qu'il s'agit d'un problème avec VS Code. J'utilise GNOME depuis des jours, avec d'autres applications Electron ouvertes (Slack, Pulse, etc.), et je n'ai pas eu un seul gel. J'ai DM'd VS Code sur Twitter et je ferai probablement un rapport de bogue car ils n'ont pas encore répondu.


Panélistes répondant :

Tyler Gakstatter

Quelque chose lié à Python provoque un blocage d'ArcGIS for Desktop ? - Systèmes d'information géographique

TSTL : le langage de test de script de modèle

TSTL est un langage spécifique à un domaine (DSL) et un ensemble d'outils pour prendre en charge la génération automatisée de tests pour les logiciels. Cette implémentation cible Python. Vous définissez (en Python) un ensemble de composants utilisés pour créer un test et toutes les propriétés que vous souhaitez conserver pour le système testé, et TSTL génère des tests pour votre système. TSTL prend en charge la relecture des tests, la réduction des tests et l'analyse de la couverture du code, et inclut la prise en charge des boutons-poussoirs pour certaines méthodes sophistiquées de génération de tests. En d'autres termes, TSTL est un test basé sur les propriétés outil.

Qu'est-ce que les tests basés sur les propriétés ? Les tests basés sur les propriétés sont des tests qui ne reposent pas sur la spécification des résultats par les développeurs pour des entrées ou des séquences d'appels spécifiques, mais sur une spécification plus générale du comportement, combinée à la génération automatique de nombreux tests pour s'assurer que la spécification générale est valable. Pour en savoir plus sur les tests basés sur les propriétés, consultez :

https://github.com/trailofbits/deepstate (un outil mélangeant analyse symbolique et fuzzing avec des tests basés sur les propriétés, pour C et C++, avec une conception quelque peu informée par TSTL)

Vous pouvez récupérer un tstl récent plus facilement en utilisant pip. pip install tstl devrait fonctionner correctement. Si vous voulez quelque chose d'encore plus récent, vous pouvez faire :

Pour la couverture du code, vous aurez également besoin d'installer la couverture d'installation pip de l'outil Coverage.py de Ned Batchelder est tout ce qui est nécessaire.

Pour avoir une idée du fonctionnement de TSTL, essayons un exemple de jouet. Nous utiliserons TSTL pour résoudre un simple "puzzle" pour voir s'il est possible de générer la valeur entière 510 en utilisant seulement quelques lignes de code Python, en utilisant seulement un petit ensemble d'opérations (ajouter 4, soustraire 3, multiplier par 3, et produire une puissance de deux) à partir de 0.

Comme en Python normal, # indique un commentaire. Les lignes de commentaires se trouvent sous le code TSTL décrit.

Cela devrait, en quelques secondes, trouver un moyen de violer la propriété (produire la valeur 510), trouver une version au maximum simple de ce "test d'échec" et produire un fichier nutshell.test qui contient le test. Si nous avions omis le TSTL aurait soit trouvé un moyen de produire 510, soit (moins probable) aurait trouvé un moyen de produire un débordement dans le pow call : l'un ou l'autre serait considéré comme un échec.

Cela rejouera le test que vous venez de créer.

L'idée centrale de TSTL est de définir un ensemble d'étapes possibles dans un test, ainsi que des propriétés décrivant ce qui peut être considéré comme un échec de test, et de laisser TSTL découvrir s'il existe une séquence d'actions qui produira un échec de test. Les actions peuvent être des appels de fonction ou de méthode, ou des étapes qui assemblent des données d'entrée (par exemple, créer une chaîne à transmettre à un analyseur), ou, vraiment, tout ce que vous pouvez faire avec Python.

TSTL installe quelques outils standards : le compilateur TSTL lui-même, tstl un générateur de tests aléatoires tstl_rt un outil pour produire des tests autonomes, tstl_standalone un outil pour rejouer les fichiers de test TSTL, tstl_replay un outil pour le débogage delta et la normalisation des tests TSTL, tstl_reduce et un outil pour exécuter un ensemble de tests en tant que régression, tstl_regress .

Vous pouvez faire la plupart de ce dont vous aurez besoin avec uniquement les commandes tstl , tstl_rt , tstl_replay et tstl_reduce .

  • tstl <filename.tstl> compile un fichier .tstl dans une interface sut.py pour le test
  • tstl_rt exécute des tests aléatoires sur le sut.py dans le répertoire actuel et vide tous les défauts découverts dans les fichiers .test
  • tstl_replay <filename.test> exécute un test TSTL enregistré et vous indique s'il réussit ou échoue avec --verbose, il fournit une trace assez détaillée de l'exécution du test
  • tstl_reduce <filename.test> <newfilename.tstl> prend <filename.test> exécute une réduction et une normalisation dessus pour produire un test plus court et plus facile à comprendre, et enregistre la sortie sous <newfilename.tstl> .

Tous ces outils offrent un grand nombre d'options de configuration --help produira une liste des options prises en charge pour tous les outils TSTL.

Le moyen le plus simple de comprendre TSTL peut être d'examiner examples/AVL/avlnew.tstl (https://github.com/agroce/tstl/blob/master/examples/AVL/avlnew.tstl), qui est un simple fichier d'exemple dans le dernier format de langue.

avlnew.tstl crée un testeur assez complet pour une classe d'arborescence AVL. Cependant, vous pouvez écrire quelque chose de très rapide et assez efficace avec seulement quelques lignes de code :

Cela dit qu'il y a deux sortes de "choses" impliquées dans nos tests d'implémentation de l'arborescence AVL : int et avl . Nous définissons, en Python, comment créer ces choses, et ce que nous pouvons faire avec ces choses, puis TSTL produit des séquences d'actions, c'est-à-dire essais, qui correspondent à notre définition. TSTL vérifie également que tous les arbres AVL, à tout moment, sont correctement équilibrés. Si nous voulions, comme dans avlnew.tstl , nous pourrions également nous assurer que notre arbre AVL "agit comme" un ensemble --- lorsque nous insérons quelque chose, nous pouvons trouver cette chose, et lorsque nous supprimons quelque chose, nous ne pouvons plus trouver il.

Notez que nous commençons par "raw Python" pour importer le module avl, le SUT. Bien que TSTL prenne en charge l'utilisation de from, d'alias et de caractères génériques dans les importations, vous devez toujours importer le ou les modules testés avec une simple importation. Cela permet à TSTL d'identifier le code à tester et de fournir automatiquement une couverture, des méthodes de test assistées par analyse statique et une gestion de module appropriée. Le code utilitaire dans la bibliothèque standard, d'autre part, peut être importé comme vous le souhaitez.

Si nous testons ceci (ou avlnew.tstl ) pendant 30 secondes, quelque chose comme ceci apparaîtra :

/tstl/examples/AVL$ tstl_rt --timeout 30

Pour de nombreux programmes (mais pas tous !), une alternative plus puissante aux tests aléatoires simples consiste à utiliser des tests en essaim, qui limitent les actions dans chaque test individuel (par exemple, insérer mais pas supprimer, ou rechercher mais pas de traversées dans l'ordre) (voir http ://agroce.github.io/issta12.pdf).

Ici, la méthode n'est pas très importante. Un simple test aléatoire fait un travail décent couvrant le code de l'arbre AVL en seulement 60 secondes. Si nous introduisons un bogue en supprimant l'appel self.rebalance() à la ligne 205 de avl.py, l'une ou l'autre méthode signalera rapidement un cas de test défaillant, automatiquement réduit. Par défaut, le testeur aléatoire exécutera le test en mode verbeux pour montrer plus en détail ce qui se passe pendant l'exécution qui provoque un échec.

En utilisant --output , le test échoué peut être enregistré dans un fichier nommé, et avec l'utilitaire standalone.py, converti en un cas de test complètement autonome qui ne nécessite pas TSTL lui-même. Sans --output, le test est toujours enregistré, mais le nom est basé sur l'ID de processus de tstl_rt . Dans les deux cas, vous pouvez facilement réexécuter un test enregistré, même sans le convertir en test autonome, en utilisant tstl_replay <testname> , et le réduire en utilisant tstl_reduce . L'indicateur --verbose est utile pour la relecture, car il vous montrera exactement ce qui se passe pendant un test.

Le dernier conseil utile pour commencer est que parfois vous voudrez peut-être tester quelque chose (par exemple, une bibliothèque implémentée en C) où les tests échoués plantent l'interpréteur Python. C'est possible, mais demande un certain effort. Tout d'abord, exécutez tstl_rt avec l'option --replayable. Cela oblige le générateur à conserver un fichier, currtest.test , dans le répertoire dans lequel vous exécutez le test : ce fichier contient le test en cours. Si le testeur aléatoire tombe en panne, cela inclura l'action qui a causé le plantage. Dans quelques rares cas, le comportement des tests passés est également pertinent pour un crash (le rechargement du module ne réinitialise pas vraiment l'état du système - par exemple, l'interaction avec le matériel). Pour ces cas, utilisez --total et regardez le fichier fulltest.test , qui contient TOUTES les actions jamais effectuées par le testeur aléatoire.

Les fichiers currtest.test et fulltest.test fonctionnent comme les fichiers TSTL normaux et peuvent être rejoués avec l'utilitaire de relecture ou transformés en fichiers autonomes. Cependant, pour que la réduction et la normalisation des tests fonctionnent correctement, ils doivent être réduits en passant l'argument --sandbox à tstl_reduce .

Qu'en est-il des tests qui échouent en entrant dans une boucle infinie ? La même technique que celle utilisée pour les crashs fonctionne. Cependant, vous devez exécuter tstl_rt avec une limite de temps (en utilisant ulimit si vous êtes sur des systèmes de type UNIX, par exemple). L'utilitaire tstl_reduce fournit un argument --timeout pour gérer de tels tests, mais cela ne fonctionne que sur les systèmes prenant en charge ulimit, pour le moment. Dans de très rares cas, vous pouvez avoir un blocage d'exécution de test car, par exemple, l'échec provoque une lecture à partir de l'entrée standard. Si vous touchez ceci, contactez-moi.

Enfin, comment intégrez-vous les tests TSTL à des approches plus conventionnelles, par exemple pytest ? Le fichier test_tstl_regressions.py dans le répertoire des exemples montre une façon. Si vous ajoutez tous vos tests TSTL d'intérêt à un répertoire tstl_tests sous le répertoire où se trouve sut.py, vous pouvez faire en sorte que pytest exécute tous vos tests TSTL. Peut-être plus intéressant encore, ce fichier encapsule également un simple appelant qui force 60 secondes de tests aléatoires à être exécutés par pytest, en tant que contrôle de cohérence. Vous pouvez facilement modifier la configuration des tests aléatoires - souvent, l'ajout de "--swarm" est une bonne idée.

TSTL et tests de mutation

En utilisant l'outil universalmutator, vous pouvez facilement étudier la puissance de vos harnais de test TSTL pour trouver des bogues. Par exemple, si nous voulions voir à quel point 10 secondes de tests aléatoires avec notre harnais AVL sont efficaces, nous pourrions le faire :

Cela rapporte le score des mutants que nos tests ne couvrent même pas, ce qui peut être de peu d'intérêt si nous ne ciblons qu'une partie d'une API. Et, franchement, il existe des moyens plus faciles de voir quel code n'est pas couvert que d'utiliser des tests de mutation ! Nous pouvons donc vouloir limiter notre analyse au code réellement couvert par le harnais AVL, en utilisant un délai d'attente généreusement important :

Parfois, il ne suffit pas de faire tstl_rt ou même tstl_rt --swarm. Il existe d'autres options pour améliorer les tests. L'utilisation de la taille des fonctions en termes de lignes de code pour guider les tests est particulièrement puissante dans de nombreux cas. Pour ce faire, vous laissez d'abord TSTL déterminer les tailles :

tstl_rt --generateLOC sut.loc --timeout 120

Ensuite, vous utilisez ce fichier généré pour guider les tests :

C'est aussi une bonne idée, pour des tests plus rapides (puisque la puissance des tests aléatoires réside en partie dans la génération d'un grand nombre de tests chaque minute), de désactiver la collecte de couverture de code avec --noCover . Ce n'est pas très bien si vous cherchez à voir si vos tests couvrent bien votre code, mais pour la chasse aux bogues de pédale à métal, c'est souvent la voie à suivre.

Il y a d'autres choses qui peuvent améliorer les tests. L'option --profileProbs rassemble des informations sur la fréquence à laquelle chaque action du harnais TSTL a été effectuée pendant les tests et oriente linéairement le choix d'action aléatoire vers des actions qui ont été effectuées moins de fois. Cela ralentit considérablement la génération de tests dans la plupart des cas, mais pour de nombreux programmes (en particulier les plus complexes), cela améliore également considérablement la couverture du code et la détection des pannes, en explorant les actions difficiles à atteindre et en passant moins de temps à générer des données d'entrée par rapport à l'exécution du SUT. . Dans ces cas, la perte de débit de test produite par les tentatives d'entreprendre des actions probablement invalidées est bien plus que compensée par une amélioration de la qualité des tests. Parce que les deux reposent sur la définition des probabilités d'action, --profileProbs et --biasLOC ne sont malheureusement pas compatibles.

Pour certains programmes, la structure du fichier de harnais ralentit la génération des tests et l'option --useDependencies peut améliorer le débit des tests d'un facteur 2 à 10. Cependant, pour la plupart des programmes, cette option ralentit la génération de tests d'environ un facteur de deux.

Étant donné que l'utilité de ces options varie considérablement, il est préférable de simplement les essayer. Pour --profileProbs, vous devriez voir une forte augmentation de la couverture de code s'il est efficace pour votre problème de test (probablement accompagné d'une forte baisse du nombre de tests générés), et pour --useDependencies vous devriez voir une forte augmentation du nombre des tests/opérations de test effectués.

Vous pouvez également essayer une approche « algorithmes génétiques » guidée par la couverture, qui exploite des tests « haute couverture » :

tstl_rt --exploit 0.8 --Pmutate 0.5

L'ajout de --reducePool améliore parfois également les performances de cette méthode.

Vous pouvez régler les paramètres d'exploit et de mutation pour voir s'ils améliorent les résultats. Vous pouvez même combiner des biais de lignes de code ou des probabilités basées sur le profil avec l'approche d'exploit et/ou les tests en essaim. Malheureusement, l'utilisation de --exploit signifie que vous ne pouvez pas vous en sortir avec --noCover pour éviter la surcharge de calcul de la couverture du code.

Nous travaillons sur un moyen pour que TSTL effectue des expériences automatiquement et vous conseille la meilleure configuration pour tester un harnais donné.

Pour obtenir un ensemble de "tests de régression" très rapides, vous pouvez exécuter tstl_rt pendant longtemps dans une bonne configuration avec l'option --quickTests, et générer un ensemble de tests très courts avec une couverture de code élevée.

TSTL prend en charge la localisation automatisée des défauts. Si vous avez un harnais qui trouve un bogue, vous pouvez avoir un aperçu de la nature de ce bogue en exécutant quelque chose comme :

Cela exécutera TSTL pendant une heure, générera un certain nombre de cas de test défaillants (si votre bogue peut être trouvé relativement facilement en une heure), puis rapportera les 20 déclarations et branches les plus probables dans le code testé. Une partie de ce code peut être impliquée dans des choses comme l'impression de valeurs d'assertion ou la gestion d'erreurs pour la faute, mais il y a de fortes chances que vous trouviez le code bogué dans les résultats de la localisation, d'après notre expérience. En fait, une course de cinq minutes suffira pour une bonne localisation, souvent, si cinq minutes suffisent pour trouver votre bug plusieurs fois. Notez que les résultats sont bien pires si vous avez plus d'un bug !

Une façon d'utiliser efficacement les tests en essaim est d'appliquer essai d'essaim dirigé, une approche où les données sur la façon dont swarm interagit avec la couverture du code sont utilisées pour augmenter la couverture des instructions et des branches rarement couvertes.

Pour ce faire, exécutez votre test initial à l'aide de tstl_rt (pendant une heure ou plus) avec les options :

Cela testera votre programme et produira deux fichiers intéressants. <filename2> contiendra un simple fichier texte avec les branches et les instructions couvertes, classées par le nombre de fois où elles ont été couvertes. Il s'agit essentiellement d'une version simplifiée du type de sortie que vous connaissez peut-être à partir de gcov ou d'autres outils. Vous pouvez consulter ce fichier et identifier un code intéressant, mais rarement couvert.

Ensuite, prenez l'identifiant (la chaîne complète, parenthèses comprises) du code intéressant et utilisez l'outil tstl_directedswarm comme ceci :

tstl_directedswarm <filename1> "<coverage target>" <probFile>

( <filename1> est le fichier que vous avez produit lors de l'exécution initiale du test de l'essaim.) Cela tentera de déterminer quelles actions aident ("déclencher") et entravent ("supprime") la couverture du code cible, et produira un fichier ( probFile ) avec des probabilités pour une utilisation dans des tests d'essaim plus ciblés. Si l'outil n'identifie aucun déclencheur ou suppresseur, essayez à nouveau de l'exécuter avec l'option --confidence et un nombre inférieur à 0,95 plus la confiance requise est faible, plus vous avez de chances de trouver des déclencheurs et des suppresseurs, mais moins ils sont susceptibles pour être significatif - vous pouvez essayer de baisser lentement jusqu'à ce que vous obteniez des résultats. Ensuite, exécutez à nouveau le test, comme ceci :

tstl_rt --swarm --swarmProbs <probFile>

Vous devriez généralement être en mesure de bien couvrir le code rarement couvert de cette façon. Étant donné que couvrir du code rarement couvert révèle souvent un nouveau code intéressant et jamais vu auparavant, vous voudrez peut-être répéter ce processus une fois que vous aurez exploré le code rarement couvert de votre exécution initiale. Vous pouvez, bien sûr, stocker une couverture d'essaim et des statistiques de couverture complète pour les exécutions ciblées de TSTL, et continuer à explorer.

Une manière plus systématique de procéder aux tests d'essaims dirigés consiste à essayer :

tstl_analyzeswarm <filename1> <prefix> --cutoff 0.5

pour générer des déclencheurs et des suppresseurs pour TOUTES les cibles de couverture atteintes au cours d'une exécution, regroupées en classes d'équivalence (cibles avec le même ensemble de déclencheurs et de suppresseurs) et classées par la cible la moins touchée dans chaque classe d'équivalence. La sortie sera stockée dans des fichiers commençant par <prefix> : un ensemble de fichiers nommés <prefix>.N.probs qui peuvent être utilisés avec --swarmProbs , et un seul fichier .class, avec toutes les cibles, déclencheurs, suppresseurs et fréquences minimales pour les classes , plus des pointeurs vers les fichiers de probabilité associés. Le simple fait de parcourir les fichiers de probabilité générés pour les classes des cibles les plus rares est un bon moyen de procéder à des tests d'essaim dirigés. Le 0,5 ci-dessus peut être n'importe quel seuil, au-dessus duquel les cibles atteintes par au moins cette fraction de tests sont considérées comme bien testées et ignorées. Un réglage aussi bas que 0,01 peut bien fonctionner, pour les premières exécutions produisant un grand nombre de tests.

TSTL et le Fuzzer américain Fuzzy Lop (AFL)

Vous pouvez même utiliser AFL (http://lcamtuf.coredump.cx/afl/) pour générer des tests TSTL. Vous devez installer AFL lui-même et le package pip python-afl (ou récupérer le code de github à l'adresse https://github.com/jwilk/python-afl). Ensuite, vous pouvez utiliser AFL dans n'importe quel répertoire avec un harnais TSTL compilé :

tstl_afl_fuzz --output <outputdir> --input <inputdir>

Cela utilisera certains paramètres par défaut (généralement bons) pour que TSTL génère d'abord de bons tests de démarrage pour AFL sur lesquels s'appuyer, puis exécutera AFL pendant une journée sur le SUT. Un jour peut ne pas suffire, le même paramètre --timeout est donc pris en charge par le testeur aléatoire TSTL. Vous pouvez également utiliser le test swarm en ajoutant --swarm . Il existe également d'autres options, moins fréquemment utilisées. Les tests échoués générés par AFL seront stockés sous le nom aflfail.<PID>.test dans le répertoire courant. Un conseil : <outputdir> devrait probablement être un disque virtuel, à moins que vous ne vouliez vraiment marteler votre SSD (ne pensez même pas à le faire sur un vrai disque dur).

Vous devriez également essayer l'option --persist de tstl_afl_fuzz , qui améliorera souvent considérablement la vitesse de fuzzing et améliorera considérablement les résultats AFL (puisque le débit est si critique), cependant, c'est un peu moins bien testé que le mode non persistant . Avec plus de tests, cela deviendra probablement le paramètre par défaut, vous voudrez donc peut-être prendre de l'avance et n'exécuter de manière non persistante que si le mode persistant semble causer des problèmes.

Il s'agit d'une option de test puissante, car elle vous permet d'utiliser les excellentes heuristiques d'AFL pour brouiller les choses qui sont au mieux très gênantes avec juste AFL. Vous pouvez configurer des propriétés TSTL complexes, mélanger la génération de grammaire et des séquences d'appels d'API et effectuer des tests différentiels de style TSTL, mais utilisez les méthodes de génération d'entrée ajustées d'AFL. Le principal inconvénient est qu'AFL s'attend vraiment à des exécutables beaucoup plus rapides que ce que TSTL lui donne, vous devez donc probablement courir pendant des jours pour améliorer ce que TSTL peut faire en une heure, à moins que votre SUT ne soit inhabituel. Mais c'est certainement une option intéressante pour des tests intensifs d'une semaine lorsque tstl_rt ne trouve aucun problème.

Notez que si vous n'utilisez pas tstl_afl_fuzz mais appelez directement py-afl-fuzz, vous avez probablement besoin (sauf sur Mac OS, où la limitation de mémoire ne fonctionne pas de toute façon) d'un grand -m pour que TSTL fonctionne.

Sous le capot, la commande tstl_afl prend un fichier d'octets et interprète tous les N octets (N dépend du nombre d'actions de votre harnais) comme l'index d'une action TSTL (modulo le nombre d'actions), en utilisant sut.py comme d'habitude. Lorsque tstl_afl détecte une défaillance, il produit également un fichier de test TSTL conventionnel sous le nom aflfail.<PID>.test . Vous pouvez même utiliser --swarm pour interpréter les 4 premiers octets comme une graine pour contrôler les tests d'essaims, permettant ainsi à AFL d'utiliser les tests d'essaims, cela présente l'inconvénient que le fichier sera interprété de manière incorrecte par d'autres outils TSTL, à moins que vous ne leur passiez le - -option aflswarm. La plupart des outils TSTL prennent une option --afl qui indique que les tests à lire sont au format AFL et --aflswarm pour indiquer qu'il s'agit de tests en essaim.

tstl_afl est également utile pour transformer un seul fichier d'octets AFL en un fichier de test TSTL normal, en utilisant l'option --alwaysSave, qui vide un fichier de test TSTL dans le répertoire actuel, créé à partir de l'entrée basée sur les octets.

Il existe également des outils pour convertir un grand nombre de fichiers vers et depuis le format AFL. tstl_toafl prend simplement les fichiers de test TSTL existants et les convertit en entrées d'octets AFL, et tstl_fromafl fait le contraire attendu (et prend un argument indiquant que les fichiers sont au format swarm). tstl_aflcorpus génère de manière aléatoire des entrées qui déclenchent une nouvelle couverture SUT pour démarrer AFL, mais il est généralement plus facile de générer des tests rapides avec tstl_rt --quickTests et de les convertir avec tstl_toafl . tstl_aflcorpus permet d'utiliser le format d'essaim AFL, mais il suffit de l'exécuter avec --swarm . En raison du fonctionnement du format swarm, il n'est malheureusement pas possible actuellement d'extraire un test de format swarm à partir d'un test TSTL standard.

tstl_smallcheck est un générateur de tests à usage spécial qui utilise une recherche en profondeur d'abord pour générer de manière exhaustive des tests jusqu'à une limite de profondeur fournie. L'outil génère des tests d'augmentation de la couverture et s'arrête s'il rencontre un échec. Cela se terminera rarement si la profondeur est supérieure à 3 à 10 (au plus) pas, à moins qu'il ne rencontre un échec. Si vous manquez de patience, vous pouvez interrompre le processus avec CTRL-C et l'outil enregistrera les tests découverts.

Une façon d'obtenir des tests « exhaustifs » plus approfondis consiste à utiliser l'option --recursive pour explorer à partir de tests d'augmentation de la couverture, de manière répétée jusqu'à un nombre limité de fois, en utilisant la même profondeur que l'exécution d'origine (et une petite profondeur initiale).

Si vous souhaitez collecter tous les tests qui échouent, et pas seulement vous arrêter au premier, vous devrez utiliser l'option --multiple. En raison de leur petite taille et de la volonté présumée d'exploration exhaustive (vous avez utilisé cet outil, après tout), cet outil n'offre ni réduction ni normalisation des tests de couverture ou des échecs, pour éviter tout risque de dérapage.

En plus de --recursive , vous pouvez utiliser --visited ou --visitedList pour éviter de revisiter des états déjà explorés pendant le DFS, cependant, cela nécessite quelques précautions. Si l'outil échoue ou si les tests ne semblent pas valides/corrects, vous pouvez recompiler votre harnais avec --defaultReplay , car le backtracking basé sur l'état ne fonctionne pas. Dans de nombreux cas, en raison du coût élevé de la comparaison d'états dans ce cadre, le suivi des états visités peut même ne pas être très utile.

Les tests aléatoires utilisant tstl_rt sont probablement presque toujours plus efficaces que cette approche, mais tstl_smallcheck peut fournir des garanties que tstl_rt ne peut pas, par exemple qu'aucun test avec moins de quatre étapes ne peut provoquer d'échec. Lancer une petite vérification à partir de tests rapides existants à l'aide de l'option --fromTests est un moyen d'ajouter une confiance supplémentaire dans vos tests.

Certains d'entre vous se demandent peut-être : "En quoi TSTL diffère-t-il de l'outil de test Hypothesis https://hypothesis.readthedocs.io/en/latest/ ?" Il y a quelques réponses. Premièrement, TSTL est probablement beaucoup moins poli que Hypothesis, en ce moment ! Plus important encore, Hypothesis et TSTL génèrent tous deux des tests, mais ils sont principalement destinés à générer différents types de tests. Hypothesis fait partie de ce que nous considérons comme la famille QuickCheck : si vous avez une fonction f qui prend en entrée une liste, une chaîne ou quelque chose de plus complexe, Hypothesis est très probablement ce que vous voulez utiliser. Si vous avez un ensemble de fonctions, f , g et h , et qu'elles ne renvoient pas seulement des choses, mais modifient l'état du système invisible (mais renvoient également des choses qui peuvent être des entrées pour d'autres fonctions), vous voudrez peut-être TSTL. Vous pouvez effectuer des tests de séquence d'appels de méthode basés sur l'état avec Hypothesis, mais cela peut être plus facile avec TSTL, et c'est pour cela que TSTL est conçu. Donc, si vous testez une implémentation de tri, Hypothesis est presque certainement bien meilleur. Si vous testez quelque chose comme un système de fichiers, vous voudrez peut-être examiner TSTL. Si vous testez un analyseur qui prend une chaîne en entrée, les deux outils peuvent être utiles, selon votre situation. Une différence supplémentaire pour l'utilisateur typique est que TSTL dispose d'un support intégré considérable pour effectuer des tests différentiels/de référence, où votre SUT est comparé à une implémentation de référence, éventuellement avec du code pour gérer les différences attendues (voir l'exemple pyfakefs pour un bon aperçu à quel point cela peut être puissant). Enfin, TSTL est conçu comme un outil de test pratique, mais sa conception est fortement influencée par la décision de le rendre utile en tant que plate-forme pour expérimenter de nouveaux algorithmes de test de logiciels.

La similitude est que TSTL et Hypothesis ne ressemblent pas aux tests unitaires traditionnels. They instead let you define the idea of a valid input (either some data values, or in TSTL a sequence of method calls and assignments that more resembles a traditional do-some-stuff-and-then-check-it unit test) and assert general properties about the behavior of a system under valid input.

Tips for Handling Numerous Bugs

If you test real software with a good harness, you may well find many issues. There are a few ways to deal with this. First, using --normalize when doing --multiple runs with tstl_rt can help. In some cases (file systems) normalization (or even reduction) goes too far. In testing at NASA, we found that "last operation" was a good heuristic for different bugs. Using --keepLast in testing (or when using tstl_reduce ) forces reduction and normalization to leave the last step alone. Normalization can still move it around, or change the pool it uses, but is much more careful about changing the actual action performed. There is also a tool tstl_triage that takes a glob expression for a set of tests, runs them all, and reports ones with different (heuristic) failure signatures. In particular, it gives you the shortest test for each signature. Remember that triage requires a glob expression (in quotes) not a list of files. This is so it can handle even sets of tests that go beyond the shell expansion limit. We assume that you won't need to handle that many tests in regression, but for triage, who knows? Another tool, tstl_fpf takes similar arguments to tstl_triage but instead of clustering tests into groups that are likely the same bug, it ranks all tests, such that very different tests are high in the ranking, using the "furthest-point-first" (FPF) method proposed by Chen et. al in PLDI 2013.

For more details on TSTL, the best starting point is a comprehensive journal paper in STTT: http://agroce.github.io/sttt17.pdf. There are also NASA Formal Methods (NFM) and International Symposium on Software Testing and Analysis (ISSTA) 2015 papers at http://agroce.github.io/nfm15.pdf and http://agroce.github.io/issta15.pdf, with some implementation details or concepts that are not present in the more up-to-date and complete paper. In particular, the NFM paper, "A Little* Language for Testing" has a deprecated syntax and other issues, but is the most concise explanation of the core TSTL idea: a DSL embedding a full programming language, designed to make testing (and building testing tools) easy.

There is a more recent paper describing test normalization, a feature unique to TSTL, in more detail, http://agroce.github.io/issta17.pdf, as well as a tool paper describing how to use TSTL's test manipulation commands (http://agroce.github.io/issta17tool.pdf).

The NFM and ISSTA papers use an early version of TSTL syntax, which marks pools and TSTL constructs with % signs. "Modern" TSTL uses <> by default, though if for some reason you need <> in your code (and to prepare for a future C++ version) this can be turned off and only % supported.

Note that documentation above is preliminary. The best way to get started, once you understand the basic tools ( tstl , tstl_rt , tstl_replay , and tstl_reduce ) is to examine the examples directory and try out real TSTL test harnesses. For the brave, reading tstl/randomtester.py provides considerable guidance in how to (efficiently) use TSTL in a generic testing tool, with TSTL providing an interface to the underlying application/library to be tested.

Note that TSTL was originally written for Python 2.7, has mostly been developed/tested that way, and is not extremely well-tested yet with Python 3.0+. However, it should work ok, thanks to mrbean-bremen, and the Travis tests check that TSTL works fine on Python 3.6. Earlier 3.0+ versions may have some "gotchas."

There are no developer docs yet, which will hopefully change in the future. The best shakedown test for tstl is to compile and run (using tstl_rt ) the AVL example. Removing any call to the balancing function in the avl.py code should cause TSTL to produce a failing test case.

Who is responsible for TSTL?

Alex Groce (agroce) wrote this file, and most of the current code base, and is running the show. If there is a problem with TSTL, it is my fault, and don't blame anyone below.

Josie Holmes (josieholmes) contributed to core language design changes, and is responsible for the ideas (and some of the code) for the various slippage reduction strategies, plus the LOC bias work and Markov things. Before Josie's work, TSTL was extremely hard to read, and considerably less efficient.

Jervis Pinto was the other original TSTL-er, and has his fingerprints on various parts of the early design and code that form the foundations of TSTL.

Pranjal Mittal contributed a number of critical elements, including the initial effort to prepare TSTL for a pip release as a useful tool, and has helped publicize TSTL.

Pooria Azimi added the <int,1> notation, which turns out to be one of the most important changes, and eliminated the need for the exceedingly awkward way of handling binding via Python functions and commit point based guards. Without this, you really don't have a useful TSTL.

Kevin Kellar developed a (beta) Java version of TSTL: https://github.com/flipturnapps/TSTL-Java.

My (Alex's) other graduate students (Amin Alipour, Rahul Gopinath, Arpit Christi, Chaoqiang Zhang, Shalini Shamasunder) and almost-mine graduate student (Iftekhar Ahmed) contributed to the general intellectual climate in which TSTL was born.

Students in CS 499 at Northern Arizona University and CS 362, 562, and 569 at Oregon State University contributed a lot of ideas, and a few concrete language/tool changes or bug reports. These are too numerous to mention, and in some cases I don't recall who asked "why do you do it that stupid way?" in class, and got me thinking that it was in fact a stupid way to do things.

Ned Batchelder, David R. MacIver, and John Regehr have no actual code in TSTL, but all contributed in significant ways to various implementation aspects, in ways that go beyond the general disclaimer that TSTL freely steals from the entire software testing (research) community.

The pyfakefs team (mrbean-bremen and jmcgeheeiv on github) really worked with me to test pyfakefs, which resulted in a number of nice improvements to TSTL and to differential testing in particular. More recently, mrbean-bremen has taken the lead in making TSTL compatible with Python 3, which seems to mostly be done now!

Jakub Wilk helped with modifications to python-afl that made TSTL/AFL integration work much better.

Corey Kosak helped turn this README into something that you might actually enjoy reading, and gets to the point much faster than previous versions.

* Do you actually remember that asterisk way up there? The footnote is that TSTL is a little language. However, in another sense, it embeds all of Python which makes it pretty big. It depends on how you think about it.


My Pi keeps crashing — where should I look?

I know my problem is too vague to solve the root problem. Please help me on my way.

My problem
I have a Pi setup with owncloud. And a external hard drive with videos on it.
It just functions as a NAS. I use SFTP for all my connections.
But it (seemingly) crashes at random. It crashed last night when it was idling, and does so a few times a week. Pulling the plug and reinserting it creates a successful reboot.

  • It's a Pi 2 Model B.
  • I tried 2 different power supplies for the Pi. Neither had problems with an older Pi model.
  • The external drive is externally powered.
  • I run the Pi headless.
  • When it crashes I can't login or reach it in any way. The power LED is lit.

My question:

  • Where should I look to narrow this down?
  • What might I do the log this behaviour?
  • Where is a place to get more specific support for this kind of broad, vague problems?

What helped so far

A comment made by Goldilocks to determine the difference if it really crashes or I just can log in.


As stuff is stored into, left, and eventually pulled out of RAM, some corruption naturally occurs (theories vary, but the one with the most weight right now is EMI from the computer itself). ECC is a feature of RAM and motherboards that allows detection and correction of this corruption.

The corruption is usually pretty minor (ECC can usually detect and fix 1-2 bits per 64 bit "word" - and that's waaaaay beyond the typical error rates), but increases in frequency with the density of the RAM. Your average workstation/PC will never notice it. On a server where you're running high density RAM 24/7 in a high-demand environment serving critical services, you take every step you possibly can to prevent stuff from breaking.

Also note that ECC RAM must be supported by your motherboard, and the average workstation/PC does not support it.

ECC RAM is more expensive than non-ECC, is much more sensitive to clock speeds, and can incur a small (1-2%) performance hit. If it helps, an analogy that works is RAM to RAID controllers. On your PC, that hardware-assisted software RAID built into your chipset is great protection against single disk failures. On a server, that would never be enough. You need high-end, battery-backed fully hardware RAID with onboard RAM to ensure that you don't lose data due to a power outage, disk failure, or whatever.

So no, you don't really need ECC RAM in your workstation. The benefit simply will not justify the price.

10% you'd expect from the additional chip area, for the same usable amount of RAM). It might be worth revisiting particularly the last sentence in light of this. &ndash user Oct 18 '15 at 13:07

If this article is anything to go by, then you should use ECC RAM.

It's not just a matter of "I don't run a server, so I don't need it". It depends how much you value your data. It's not just a matter of occasional crashes - the problem is you could get corruption and have no way of knowing that it's going on.

ECC RAM gets more interesting as memory sizes grow. The probability of a single bit error in a machine with 8GB of RAM is quite a lot higher than it was in the days of a 640K PC/XT, simply due to the larger number of bits. On a database server where that RAM might be in a disk buffer, a bit error can corrupt disk storage as well. Generally you would expect to use ECC memory on a server.

Some workstations (particularly those with Xeon or Opteron CPUs) take registered memory, which pretty much only comes in ECC flavours anyway. On a desktop PC you may view it as overkill.

ECC RAM is designed to aid in preventing and fixing memory based errors, usually using some sort of hamming code or modular redundancy. This is very useful in servers that contained important data, or need high availability, but it comes at a cost.

Whilst its probably worth paying the extra for your important servers, do you really want to do so for your desktop machine, does it matter if there is the occasionally memory error? Sure it matters if your SQL database drops some data during a transaction, but do you care if your word document is affected by a slight memory blip?

If you want a reliable workstation then you want ECC RAM for it. It will crash less often and work done on it and documents cached in RAM will not be randomly corrupted.

An additional benefit of ECC over what was mentioned above is that you can detect bad RAM. While running a long memtest86 session will usually find any problems, there may be very specific problems with the RAM which only show up rarely and in certain use cases. This can still happen much more frequently than the corruption that perfectly good ECC RAM is designed to protect against -- maybe once every month. So if you install monitoring software, you can be sure that your RAM is good, or replace bad chips. Still a marginal benefit, but as ECC memory is not much more expensive than normal RAM, it may be worth it.

ECC memory now costs about the same as non-ECC memory, as prices have dropped. So check prices if prices are anywhere close, buy ECC if your workstation accommodates it.

I think there may be some confusion just based on the title of the question.

If you just mean the average desktop PC, then that is usually based on a platform that doesn't even have ECC support.

If you mean a workstation class computer, then it quite likely comes with ECC memory whether you care about it or not.
Overall, the workstation class is typically based on essentially server hardware but with proper graphics and packaged in a different form-factor.

The expected workload is also more taxing than that of the desktop PC, so if you acknowledge that ECC makes sense for servers, then I think it's not much of a stretch that ECC also makes sense for workstations.

For Desktop PCs, there's some debate whether ECC would make sense or not. It can absolutely be argued that everything ought to have ECC but, right now, it's not practical as the industry has decided to make ECC a feature to differentiate higher end hardware.

According to the article Zan Lynx linked in the comments: DRAM Errors in the Wild: A Large-Scale Field Study, the uncorrectable errors are common while random correctable errors appear rarely in a system. The incidence is probably a few in a year, but it depends on the usage.

So in a server environment the correctable errors might not be that important, but you boot the server machines rarely, so uncorrectable errors caused by failing RAM can be there undetected for a while corrupting your data. I think that's the main reason why servers need ECC. Workstations boot and so check RAM frequently, so hardware failures can be detected by every reboot. If that frequency is sufficient for your business, then I think you won't need ECC RAM in your workstation.

If we are talking about memory errors, it is better to version the important documents on the server. So if the workstation reads and modifies something, then the original content should not be overwritten on the server. Regular backups can do the same for you.

Another aspect of this question is security. If your workstation is connected to any non-safe network, then it might be vulnerable to the row hammer attack, which exploits a DRAM related phenomenon. So from security perspective it is better to use ECC RAM.

I would use ECC everywhere, always, and I'm upset and disappointed I cannot get it on my MacBook Pro laptop, because otherwise it could completely replace my desktop server. In my desktop server, over 10 years I have had to replace 2 memory sticks due to persistent errors which would have just been random crashes and data corruption if it were not for ECC detecting and correcting them. Not counting all the errors in those failed sticks, I would estimate seeing about 8 errors per year. Of course, this is a tiny sample and anecdotal evidence a much better resource is Google's study which showed that about 1/3 of their servers experienced at least one memory error in a given year.

I agree with Linus Torvalds (creator of Linux) that the real driving force behind keeping ECC unavailable is Intel:

Torvalds takes the bold position that the lack of ECC RAM in consumer technology is Intel's fault due to the company's policy of artificial market segmentation. Intel has a vested interest in pushing deeper-pocketed businesses toward its more expensive—and profitable—server-grade CPUs rather than letting those entities effectively use the necessarily lower-margin consumer parts.

Removing support for ECC RAM from CPUs that aren't targeted directly at the server world is one of the ways Intel has kept those markets strongly segmented. Torvalds' argument here is that Intel's refusal to support ECC RAM in its consumer-targeted parts—along with its de facto near-monopoly in that space—is the real reason that ECC is nearly unavailable outside the server space.


StackTracker - Cross-platform desktop notification app

The application displays a task tray notification when someone has posted an answer or a comment to a question you are tracking on any of the StackExchange sites. Clicking the notification will open the corresponding question in your browser.

License

GPL - Full LICENSE file available in the repo (below)

Télécharger

Linux build: Download Linux ZIP (Requires Python 2.6 and PyQt4 to be installed)

Run >> python StackTracker.py from the StackTracker folder

Windows build: Download Windows ZIP (May need Microsoft VC++ DLL installed)

Launch the StackTracker.exe .

Mac OS X build: Download Mac OS X tarball (Requires Growl to be installed)

Launch StackTracker.app . Only tested in Leopard/Snow Leopard on Intel-based Macs.


kill -9 (SIGKILL) always works, provided you have the permission to kill the process. Basically either the process must be started by you and not be setuid or setgid, or you must be root. There is one exception: even root cannot send a fatal signal to PID 1 (the init process).

However kill -9 is not guaranteed to work immediately. All signals, including SIGKILL, are delivered asynchronously: the kernel may take its time to deliver them. Usually, delivering a signal takes at most a few microseconds, just the time it takes for the target to get a time slice. However, if the target has blocked the signal, the signal will be queued until the target unblocks it.

Normally, processes cannot block SIGKILL. But kernel code can, and processes execute kernel code when they call system calls. Kernel code blocks all signals when interrupting the system call would result in a badly formed data structure somewhere in the kernel, or more generally in some kernel invariant being violated. So if (due to a bug or misdesign) a system call blocks indefinitely, there may effectively be no way to kill the process. (But the process will be killed if it ever completes the system call.)

A process blocked in a system call is in uninterruptible sleep. The ps or top command will (on most unices) show it in state D (originally for “isk”, I think).

A classical case of long uninterruptible sleep is processes accessing files over NFS when the server is not responding modern implementations tend not to impose uninterruptible sleep (e.g. under Linux, the intr mount option allows a signal to interrupt NFS file accesses).

If a process remains in uninterruptible sleep for a long time, you can get information about what it's doing by attaching a debugger to it, by running a diagnostic tool such as strace or dtrace (or similar tools, depending on your unix flavor), or with other diagnostic mechanisms such as /proc/PID/syscall under Linux. See Can't kill wget process with `kill -9` for more discussion of how to investigate a process in uninterruptible sleep.

You may sometimes see entries marked Z (or H under Linux, I don't know what the distinction is) in the ps or top output. These are technically not processes, they are zombie processes, which are nothing more than an entry in the process table, kept around so that the parent process can be notified of the death of its child. They will go away when the parent process pays attention (or dies).