goto close_servers;
        }
 
-       /* Tie requests to the first four listners */
+       /* Tie requests to the first four listeners */
        err = start_clients(test_case);
        if (!ASSERT_OK(err, "start_clients"))
                goto close_clients;
 
        if (!ASSERT_EQ(link, NULL, "ptr_is_null"))
                goto cleanup;
 
-       /* and finaly execute the probe */
+       /* and finally execute the probe */
        prog_fd = bpf_program__fd(prog);
        if (!ASSERT_GE(prog_fd, 0, "bpf_program__fd"))
                goto cleanup;
 
  *     typedef int (*fn_t)(int);
  *     typedef char * const * (*fn_ptr2_t)(s_t, fn_t);
  *
- * - `fn_complext_t`: pointer to a function returning struct and accepting
+ * - `fn_complex_t`: pointer to a function returning struct and accepting
  *   union and struct. All structs and enum are anonymous and defined inline.
  *
  * - `signal_t: pointer to a function accepting a pointer to a function as an
 
 }
 
 /* Test that releasing a dynptr twice, where one of the releases happens
- * within a calback function, fails
+ * within a callback function, fails
  */
 SEC("?raw_tp")
 __failure __msg("arg 1 is an unacquired reference")
 
         * tpidr_el0 for aarch64).
         * TLS_IMM_EXEC: absolute address of GOT entry containing offset
         * from thread pointer;
-        * TLS_GENERAL_DYN: absolute addres of double GOT entry
+        * TLS_GENERAL_DYN: absolute address of double GOT entry
         * containing tls_index_t struct;
         */
        int64_t offset;
 
                return TC_ACT_SHOT;
        }
 
-       /* Skip the remainig next hops (may be zero). */
+       /* Skip the remaining next hops (may be zero). */
        return skip_next_hops(pkt, encap->unigue.hop_count -
                                           encap->unigue.next_hop - 1);
 }
  *
  *    fill_tuple(&t, foo, sizeof(struct iphdr), 123, 321)
  *
- * clang will substitue a costant for sizeof, which allows the verifier
- * to track it's value. Based on this, it can figure out the constant
+ * clang will substitute a constant for sizeof, which allows the verifier
+ * to track its value. Based on this, it can figure out the constant
  * return value, and calling code works while still being "generic" to
  * IPv4 and IPv6.
  */
 
        return sub1(v) - 1; /* compensates sub1()'s + 1 */
 }
 
-/* unfortunately verifier rejects `struct task_struct *t` as an unkown pointer
+/* unfortunately verifier rejects `struct task_struct *t` as an unknown pointer
  * type, so we need to accept pointer as integer and then cast it inside the
  * function
  */
 
        return true;
 }
 
-/* Hint, VLANs are choosen to hit network-byte-order issues */
+/* Hint, VLANs are chosen to hit network-byte-order issues */
 #define TESTVLAN 4011 /* 0xFAB */
 // #define TO_VLAN  4000 /* 0xFA0 (hint 0xOA0 = 160) */
 
 
 
        skel.detach();
 
-       /* destructor will destory underlying skeleton */
+       /* destructor will destroy underlying skeleton */
 }
 
 int main(int argc, char *argv[])
 
        struct verif_stats *prog_stats;
        int prog_stat_cnt;
 
-       /* baseline_stats is allocated and used only in comparsion mode */
+       /* baseline_stats is allocated and used only in comparison mode */
        struct verif_stats *baseline_stats;
        int baseline_stat_cnt;
 
                 * that BPF object file is incomplete and has to be statically
                 * linked into a final BPF object file; instead of bailing
                 * out, report it into stderr, mark it as skipped, and
-                * proceeed
+                * proceed
                 */
                fprintf(stderr, "Failed to open '%s': %d\n", filename, -errno);
                env.files_skipped++;