packages

Author: jsinglet

cpp/common/src/codingstandards/cpp/exclusions/c/Concurrency2.qll

@@ -0,0 +1,58 @@
+//** THIS FILE IS AUTOGENERATED, DO NOT MODIFY DIRECTLY.  **/
+import cpp
+import RuleMetadata
+import codingstandards.cpp.exclusions.RuleMetadata
+
+newtype Concurrency2Query =
+  TDoNotDestroyAMutexWhileItIsLockedQuery() or
+  TDeadlockByLockingInPredefinedOrderQuery() or
+  TWrapFunctionsThatCanSpuriouslyWakeUpInLoopQuery()
+
+predicate isConcurrency2QueryMetadata(Query query, string queryId, string ruleId) {
+  query =
+    // `Query` instance for the `doNotDestroyAMutexWhileItIsLocked` query
+    Concurrency2Package::doNotDestroyAMutexWhileItIsLockedQuery() and
+  queryId =
+    // `@id` for the `doNotDestroyAMutexWhileItIsLocked` query
+    "c/cert/do-not-destroy-a-mutex-while-it-is-locked" and
+  ruleId = "CON31-C"
+  or
+  query =
+    // `Query` instance for the `deadlockByLockingInPredefinedOrder` query
+    Concurrency2Package::deadlockByLockingInPredefinedOrderQuery() and
+  queryId =
+    // `@id` for the `deadlockByLockingInPredefinedOrder` query
+    "c/cert/deadlock-by-locking-in-predefined-order" and
+  ruleId = "CON35-C"
+  or
+  query =
+    // `Query` instance for the `wrapFunctionsThatCanSpuriouslyWakeUpInLoop` query
+    Concurrency2Package::wrapFunctionsThatCanSpuriouslyWakeUpInLoopQuery() and
+  queryId =
+    // `@id` for the `wrapFunctionsThatCanSpuriouslyWakeUpInLoop` query
+    "c/cert/wrap-functions-that-can-spuriously-wake-up-in-loop" and
+  ruleId = "CON36-C"
+}
+
+module Concurrency2Package {
+  Query doNotDestroyAMutexWhileItIsLockedQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `doNotDestroyAMutexWhileItIsLocked` query
+      TQueryC(TConcurrency2PackageQuery(TDoNotDestroyAMutexWhileItIsLockedQuery()))
+  }
+
+  Query deadlockByLockingInPredefinedOrderQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `deadlockByLockingInPredefinedOrder` query
+      TQueryC(TConcurrency2PackageQuery(TDeadlockByLockingInPredefinedOrderQuery()))
+  }
+
+  Query wrapFunctionsThatCanSpuriouslyWakeUpInLoopQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `wrapFunctionsThatCanSpuriouslyWakeUpInLoop` query
+      TQueryC(TConcurrency2PackageQuery(TWrapFunctionsThatCanSpuriouslyWakeUpInLoopQuery()))
+  }
+}

cpp/common/src/codingstandards/cpp/exclusions/c/RuleMetadata.qll

@@ -3,6 +3,7 @@ import cpp
 import codingstandards.cpp.exclusions.RuleMetadata
 //** Import packages for this language **/
 import Concurrency1
+import Concurrency2
 import IO1
 import IO2
 import IO3
@@ -21,6 +22,7 @@ import Syntax
 /** The TQuery type representing this language * */
 newtype TCQuery =
   TConcurrency1PackageQuery(Concurrency1Query q) or
+  TConcurrency2PackageQuery(Concurrency2Query q) or
   TIO1PackageQuery(IO1Query q) or
   TIO2PackageQuery(IO2Query q) or
   TIO3PackageQuery(IO3Query q) or
@@ -39,6 +41,7 @@ newtype TCQuery =
 /** The metadata predicate * */
 predicate isQueryMetadata(Query query, string queryId, string ruleId) {
   isConcurrency1QueryMetadata(query, queryId, ruleId) or
+  isConcurrency2QueryMetadata(query, queryId, ruleId) or
   isIO1QueryMetadata(query, queryId, ruleId) or
   isIO2QueryMetadata(query, queryId, ruleId) or
   isIO3QueryMetadata(query, queryId, ruleId) or

rule_packages/c/Concurrency2.json

@@ -0,0 +1,64 @@
+{
+  "CERT-C": {
+    "CON31-C": {
+      "properties": {
+        "obligation": "rule"
+      },
+      "queries": [
+        {
+          "description": "Allowing a mutex to go out of scope while it is locked removes protections around shared resources.",
+          "kind": "problem",
+          "name": "Do not destroy a mutex while it is locked",
+          "precision": "medium",
+          "severity": "error",
+          "short_name": "DoNotDestroyAMutexWhileItIsLocked",
+          "tags": [
+            "correctness",
+            "concurrency"
+          ]
+        }
+      ],
+      "title": "Do not destroy a mutex while it is locked"
+    },
+    "CON35-C": {
+      "properties": {
+        "obligation": "rule"
+      },
+      "queries": [
+        {
+          "description": "Circular waits leading to thread deadlocks may be avoided by locking in a predefined order.",
+          "kind": "problem",
+          "name": "Avoid deadlock by locking in a predefined order",
+          "precision": "very-high",
+          "severity": "error",
+          "short_name": "DeadlockByLockingInPredefinedOrder",
+          "tags": [
+            "correctness",
+            "concurrency"
+          ]
+        }
+      ],
+      "title": "Avoid deadlock by locking in a predefined order"
+    },
+    "CON36-C": {
+      "properties": {
+        "obligation": "rule"
+      },
+      "queries": [
+        {
+          "description": "Not wrapping functions that can wake up spuriously in a conditioned loop can result race conditions.",
+          "kind": "problem",
+          "name": "Wrap functions that can spuriously wake up in a loop",
+          "precision": "very-high",
+          "severity": "error",
+          "short_name": "WrapFunctionsThatCanSpuriouslyWakeUpInLoop",
+          "tags": [
+            "correctness",
+            "concurrency"
+          ]
+        }
+      ],
+      "title": "Wrap functions that can spuriously wake up in a loop"
+    }
+  }
+}