libddprof 0.5.0.1.0.beta1-x86_64-linux → 0.6.0.1.0-x86_64-linux

data/vendor/{libddprof-0.5.0/x86_64-linux-musl/libddprof-x86_64-alpine-linux-musl → libddprof-0.6.0/x86_64-linux/libddprof-x86_64-unknown-linux-gnu}/include/ddprof/ffi.h

@@ -9,7 +9,10 @@
 #include <stddef.h>
 #include <stdint.h>
 
-typedef struct ddprof_ffi_Exporter ddprof_ffi_Exporter;
+#define DDPROF_FFI_CHARSLICE_C(string) \
+  /* NOTE: Compilation fails if you pass in a char* instead of a literal */ ((ddprof_ffi_CharSlice) {.ptr = "" string, .len = sizeof(string) - 1})
+
+typedef struct ddprof_ffi_CancellationToken ddprof_ffi_CancellationToken;
 
 typedef struct ddprof_ffi_Profile ddprof_ffi_Profile;
 
@@ -21,15 +24,19 @@ typedef struct ddprof_ffi_ProfileExporterV3 ddprof_ffi_ProfileExporterV3;
  */
 typedef struct ddprof_ffi_Request ddprof_ffi_Request;
 
+typedef struct ddprof_ffi_Tag ddprof_ffi_Tag;
+
 /**
- * Buffer holds the raw parts of a Rust Vec; it should only be created from
- * Rust, never from C.
+ * Holds the raw parts of a Rust Vec; it should only be created from Rust,
+ * never from C.
+ * The names ptr and len were chosen to minimize conversion from a previous
+ * Buffer type which this has replaced to become more general.
  */
-typedef struct ddprof_ffi_Buffer {
+typedef struct ddprof_ffi_Vec_u8 {
   const uint8_t *ptr;
-  size_t len;
-  size_t capacity;
-} ddprof_ffi_Buffer;
+  uintptr_t len;
+  uintptr_t capacity;
+} ddprof_ffi_Vec_u8;
 
 typedef enum ddprof_ffi_NewProfileExporterV3Result_Tag {
   DDPROF_FFI_NEW_PROFILE_EXPORTER_V3_RESULT_OK,
@@ -43,48 +50,21 @@ typedef struct ddprof_ffi_NewProfileExporterV3Result {
       struct ddprof_ffi_ProfileExporterV3 *ok;
     };
     struct {
-      struct ddprof_ffi_Buffer err;
+      struct ddprof_ffi_Vec_u8 err;
     };
   };
 } ddprof_ffi_NewProfileExporterV3Result;
 
-typedef struct ddprof_ffi_HttpStatus {
-  uint16_t code;
-} ddprof_ffi_HttpStatus;
-
-typedef enum ddprof_ffi_SendResult_Tag {
-  DDPROF_FFI_SEND_RESULT_HTTP_RESPONSE,
-  DDPROF_FFI_SEND_RESULT_FAILURE,
-} ddprof_ffi_SendResult_Tag;
-
-typedef struct ddprof_ffi_SendResult {
-  ddprof_ffi_SendResult_Tag tag;
-  union {
-    struct {
-      struct ddprof_ffi_HttpStatus http_response;
-    };
-    struct {
-      struct ddprof_ffi_Buffer failure;
-    };
-  };
-} ddprof_ffi_SendResult;
-
-typedef struct ddprof_ffi_Slice_u8 {
-  const uint8_t *ptr;
-  size_t len;
-} ddprof_ffi_Slice_u8;
-
-typedef struct ddprof_ffi_Slice_u8 ddprof_ffi_ByteSlice;
-
-typedef struct ddprof_ffi_Field {
-  const char *name;
-  ddprof_ffi_ByteSlice value;
-} ddprof_ffi_Field;
+/**
+ * Remember, the data inside of each member is potentially coming from FFI,
+ * so every operation on it is unsafe!
+ */
+typedef struct ddprof_ffi_Slice_c_char {
+  const char *ptr;
+  uintptr_t len;
+} ddprof_ffi_Slice_c_char;
 
-typedef struct ddprof_ffi_Slice_field {
-  const struct ddprof_ffi_Field *ptr;
-  size_t len;
-} ddprof_ffi_Slice_field;
+typedef struct ddprof_ffi_Slice_c_char ddprof_ffi_CharSlice;
 
 typedef enum ddprof_ffi_EndpointV3_Tag {
   DDPROF_FFI_ENDPOINT_V3_AGENT,
@@ -92,29 +72,31 @@ typedef enum ddprof_ffi_EndpointV3_Tag {
 } ddprof_ffi_EndpointV3_Tag;
 
 typedef struct ddprof_ffi_EndpointV3_ddprof_ffi_Agentless_Body {
-  ddprof_ffi_ByteSlice _0;
-  ddprof_ffi_ByteSlice _1;
+  ddprof_ffi_CharSlice _0;
+  ddprof_ffi_CharSlice _1;
 } ddprof_ffi_EndpointV3_ddprof_ffi_Agentless_Body;
 
 typedef struct ddprof_ffi_EndpointV3 {
   ddprof_ffi_EndpointV3_Tag tag;
   union {
     struct {
-      ddprof_ffi_ByteSlice agent;
+      ddprof_ffi_CharSlice agent;
     };
     ddprof_ffi_EndpointV3_ddprof_ffi_Agentless_Body AGENTLESS;
   };
 } ddprof_ffi_EndpointV3;
 
-typedef struct ddprof_ffi_Tag {
-  ddprof_ffi_ByteSlice name;
-  ddprof_ffi_ByteSlice value;
-} ddprof_ffi_Tag;
-
-typedef struct ddprof_ffi_Slice_tag {
+/**
+ * Holds the raw parts of a Rust Vec; it should only be created from Rust,
+ * never from C.
+ * The names ptr and len were chosen to minimize conversion from a previous
+ * Buffer type which this has replaced to become more general.
+ */
+typedef struct ddprof_ffi_Vec_tag {
   const struct ddprof_ffi_Tag *ptr;
-  size_t len;
-} ddprof_ffi_Slice_tag;
+  uintptr_t len;
+  uintptr_t capacity;
+} ddprof_ffi_Vec_tag;
 
 /**
  * Represents time since the Unix Epoch in seconds plus nanoseconds.
@@ -124,29 +106,67 @@ typedef struct ddprof_ffi_Timespec {
   uint32_t nanoseconds;
 } ddprof_ffi_Timespec;
 
+/**
+ * Remember, the data inside of each member is potentially coming from FFI,
+ * so every operation on it is unsafe!
+ */
+typedef struct ddprof_ffi_Slice_u8 {
+  const uint8_t *ptr;
+  uintptr_t len;
+} ddprof_ffi_Slice_u8;
+
+/**
+ * Use to represent bytes -- does not need to be valid UTF-8.
+ */
+typedef struct ddprof_ffi_Slice_u8 ddprof_ffi_ByteSlice;
+
 typedef struct ddprof_ffi_File {
-  ddprof_ffi_ByteSlice name;
+  ddprof_ffi_CharSlice name;
   ddprof_ffi_ByteSlice file;
 } ddprof_ffi_File;
 
+/**
+ * Remember, the data inside of each member is potentially coming from FFI,
+ * so every operation on it is unsafe!
+ */
 typedef struct ddprof_ffi_Slice_file {
   const struct ddprof_ffi_File *ptr;
-  size_t len;
+  uintptr_t len;
 } ddprof_ffi_Slice_file;
 
-typedef struct ddprof_ffi_Slice_c_char {
-  const char *ptr;
-  size_t len;
-} ddprof_ffi_Slice_c_char;
+typedef struct ddprof_ffi_HttpStatus {
+  uint16_t code;
+} ddprof_ffi_HttpStatus;
+
+typedef enum ddprof_ffi_SendResult_Tag {
+  DDPROF_FFI_SEND_RESULT_HTTP_RESPONSE,
+  DDPROF_FFI_SEND_RESULT_FAILURE,
+} ddprof_ffi_SendResult_Tag;
+
+typedef struct ddprof_ffi_SendResult {
+  ddprof_ffi_SendResult_Tag tag;
+  union {
+    struct {
+      struct ddprof_ffi_HttpStatus http_response;
+    };
+    struct {
+      struct ddprof_ffi_Vec_u8 failure;
+    };
+  };
+} ddprof_ffi_SendResult;
 
 typedef struct ddprof_ffi_ValueType {
-  struct ddprof_ffi_Slice_c_char type_;
-  struct ddprof_ffi_Slice_c_char unit;
+  ddprof_ffi_CharSlice type_;
+  ddprof_ffi_CharSlice unit;
 } ddprof_ffi_ValueType;
 
+/**
+ * Remember, the data inside of each member is potentially coming from FFI,
+ * so every operation on it is unsafe!
+ */
 typedef struct ddprof_ffi_Slice_value_type {
   const struct ddprof_ffi_ValueType *ptr;
-  size_t len;
+  uintptr_t len;
 } ddprof_ffi_Slice_value_type;
 
 typedef struct ddprof_ffi_Period {
@@ -172,29 +192,29 @@ typedef struct ddprof_ffi_Mapping {
    * disk for the main binary and shared libraries, or virtual
    * abstractions like "[vdso]".
    */
-  struct ddprof_ffi_Slice_c_char filename;
+  ddprof_ffi_CharSlice filename;
   /**
    * A string that uniquely identifies a particular program version
    * with high probability. E.g., for binaries generated by GNU tools,
    * it could be the contents of the .note.gnu.build-id field.
    */
-  struct ddprof_ffi_Slice_c_char build_id;
+  ddprof_ffi_CharSlice build_id;
 } ddprof_ffi_Mapping;
 
 typedef struct ddprof_ffi_Function {
   /**
    * Name of the function, in human-readable form if available.
    */
-  struct ddprof_ffi_Slice_c_char name;
+  ddprof_ffi_CharSlice name;
   /**
    * Name of the function, as identified by the system.
    * For instance, it can be a C++ mangled name.
    */
-  struct ddprof_ffi_Slice_c_char system_name;
+  ddprof_ffi_CharSlice system_name;
   /**
    * Source file containing the function.
    */
-  struct ddprof_ffi_Slice_c_char filename;
+  ddprof_ffi_CharSlice filename;
   /**
    * Line number in source file.
    */
@@ -212,9 +232,13 @@ typedef struct ddprof_ffi_Line {
   int64_t line;
 } ddprof_ffi_Line;
 
+/**
+ * Remember, the data inside of each member is potentially coming from FFI,
+ * so every operation on it is unsafe!
+ */
 typedef struct ddprof_ffi_Slice_line {
   const struct ddprof_ffi_Line *ptr;
-  size_t len;
+  uintptr_t len;
 } ddprof_ffi_Slice_line;
 
 typedef struct ddprof_ffi_Location {
@@ -250,22 +274,30 @@ typedef struct ddprof_ffi_Location {
   bool is_folded;
 } ddprof_ffi_Location;
 
+/**
+ * Remember, the data inside of each member is potentially coming from FFI,
+ * so every operation on it is unsafe!
+ */
 typedef struct ddprof_ffi_Slice_location {
   const struct ddprof_ffi_Location *ptr;
-  size_t len;
+  uintptr_t len;
 } ddprof_ffi_Slice_location;
 
+/**
+ * Remember, the data inside of each member is potentially coming from FFI,
+ * so every operation on it is unsafe!
+ */
 typedef struct ddprof_ffi_Slice_i64 {
   const int64_t *ptr;
-  size_t len;
+  uintptr_t len;
 } ddprof_ffi_Slice_i64;
 
 typedef struct ddprof_ffi_Label {
-  struct ddprof_ffi_Slice_c_char key;
+  ddprof_ffi_CharSlice key;
   /**
    * At most one of the following must be present
    */
-  struct ddprof_ffi_Slice_c_char str;
+  ddprof_ffi_CharSlice str;
   int64_t num;
   /**
    * Should only be present when num is present.
@@ -276,12 +308,16 @@ typedef struct ddprof_ffi_Label {
    * units and units like "seconds" and "nanoseconds" as time units,
    * and apply appropriate unit conversions to these.
    */
-  struct ddprof_ffi_Slice_c_char num_unit;
+  ddprof_ffi_CharSlice num_unit;
 } ddprof_ffi_Label;
 
+/**
+ * Remember, the data inside of each member is potentially coming from FFI,
+ * so every operation on it is unsafe!
+ */
 typedef struct ddprof_ffi_Slice_label {
   const struct ddprof_ffi_Label *ptr;
-  size_t len;
+  uintptr_t len;
 } ddprof_ffi_Slice_label;
 
 typedef struct ddprof_ffi_Sample {
@@ -308,61 +344,66 @@ typedef struct ddprof_ffi_Sample {
 typedef struct ddprof_ffi_EncodedProfile {
   struct ddprof_ffi_Timespec start;
   struct ddprof_ffi_Timespec end;
-  struct ddprof_ffi_Buffer buffer;
+  struct ddprof_ffi_Vec_u8 buffer;
 } ddprof_ffi_EncodedProfile;
 
-void ddprof_ffi_NewProfileExporterV3Result_dtor(struct ddprof_ffi_NewProfileExporterV3Result result);
+typedef enum ddprof_ffi_SerializeResult_Tag {
+  DDPROF_FFI_SERIALIZE_RESULT_OK,
+  DDPROF_FFI_SERIALIZE_RESULT_ERR,
+} ddprof_ffi_SerializeResult_Tag;
 
-/**
- * Create a new Exporter, initializing the TLS stack.
- */
-struct ddprof_ffi_Exporter *ddprof_ffi_Exporter_new(void);
+typedef struct ddprof_ffi_SerializeResult {
+  ddprof_ffi_SerializeResult_Tag tag;
+  union {
+    struct {
+      struct ddprof_ffi_EncodedProfile ok;
+    };
+    struct {
+      struct ddprof_ffi_Vec_u8 err;
+    };
+  };
+} ddprof_ffi_SerializeResult;
 
-/**
- * # Safety
- * All pointers must point to valid objects for that type. If they are used as
- * arrays, such as in Slice, then they must be valid for the associated number
- * of elements. All pointers must be aligned.
- */
-struct ddprof_ffi_SendResult ddprof_ffi_Exporter_send(struct ddprof_ffi_Exporter *exporter_ptr,
-                                                      const char *http_method,
-                                                      const char *url,
-                                                      struct ddprof_ffi_Slice_field headers,
-                                                      ddprof_ffi_ByteSlice body,
-                                                      uint64_t timeout_ms);
+typedef enum ddprof_ffi_PushTagResult_Tag {
+  DDPROF_FFI_PUSH_TAG_RESULT_OK,
+  DDPROF_FFI_PUSH_TAG_RESULT_ERR,
+} ddprof_ffi_PushTagResult_Tag;
 
-/**
- * Clears the contents of the Buffer, leaving length and capacity of 0.
- * # Safety
- * The `buffer` must be created by Rust, or null.
- */
-void ddprof_ffi_Buffer_reset(struct ddprof_ffi_Buffer *buffer);
+typedef struct ddprof_ffi_PushTagResult {
+  ddprof_ffi_PushTagResult_Tag tag;
+  union {
+    struct {
+      struct ddprof_ffi_Vec_u8 err;
+    };
+  };
+} ddprof_ffi_PushTagResult;
 
-/**
- * Destroys the Exporter.
- */
-void ddprof_ffi_Exporter_delete(struct ddprof_ffi_Exporter *exporter);
+typedef struct ddprof_ffi_ParseTagsResult {
+  struct ddprof_ffi_Vec_tag tags;
+  struct ddprof_ffi_Vec_u8 *error_message;
+} ddprof_ffi_ParseTagsResult;
+
+void ddprof_ffi_NewProfileExporterV3Result_drop(struct ddprof_ffi_NewProfileExporterV3Result result);
 
 /**
  * Creates an endpoint that uses the agent.
  * # Arguments
- * * `base_url` - a ByteSlice which contains a URL with scheme, host, and port
- *                e.g. "https://agent:8126/"
+ * * `base_url` - Contains a URL with scheme, host, and port e.g. "https://agent:8126/".
  */
-struct ddprof_ffi_EndpointV3 ddprof_ffi_EndpointV3_agent(ddprof_ffi_ByteSlice base_url);
+struct ddprof_ffi_EndpointV3 ddprof_ffi_EndpointV3_agent(ddprof_ffi_CharSlice base_url);
 
 /**
  * Creates an endpoint that uses the Datadog intake directly aka agentless.
  * # Arguments
- * * `site` - a ByteSlice which contains a host and port e.g.
- *            "datadoghq.com"
- * * `api_key` - A ByteSlice which contains the Datadog API key.
+ * * `site` - Contains a host and port e.g. "datadoghq.com".
+ * * `api_key` - Contains the Datadog API key.
  */
-struct ddprof_ffi_EndpointV3 ddprof_ffi_EndpointV3_agentless(ddprof_ffi_ByteSlice site,
-                                                             ddprof_ffi_ByteSlice api_key);
+struct ddprof_ffi_EndpointV3 ddprof_ffi_EndpointV3_agentless(ddprof_ffi_CharSlice site,
+                                                             ddprof_ffi_CharSlice api_key);
 
-struct ddprof_ffi_NewProfileExporterV3Result ddprof_ffi_ProfileExporterV3_new(ddprof_ffi_ByteSlice family,
-                                                                              struct ddprof_ffi_Slice_tag tags,
+__attribute__((warn_unused_result))
+struct ddprof_ffi_NewProfileExporterV3Result ddprof_ffi_ProfileExporterV3_new(ddprof_ffi_CharSlice family,
+                                                                              const struct ddprof_ffi_Vec_tag *tags,
                                                                               struct ddprof_ffi_EndpointV3 endpoint);
 
 void ddprof_ffi_ProfileExporterV3_delete(struct ddprof_ffi_ProfileExporterV3 *exporter);
@@ -378,6 +419,7 @@ struct ddprof_ffi_Request *ddprof_ffi_ProfileExporterV3_build(struct ddprof_ffi_
                                                               struct ddprof_ffi_Timespec start,
                                                               struct ddprof_ffi_Timespec end,
                                                               struct ddprof_ffi_Slice_file files,
+                                                              const struct ddprof_ffi_Vec_tag *additional_tags,
                                                               uint64_t timeout_ms);
 
 /**
@@ -386,13 +428,58 @@ struct ddprof_ffi_Request *ddprof_ffi_ProfileExporterV3_build(struct ddprof_ffi_
  * # Arguments
  * * `exporter` - borrows the exporter for sending the request
  * * `request` - takes ownership of the request
+ * * `cancel` - borrows the cancel, if any
  *
  * # Safety
- * If the `exporter` and `request` are non-null, then they need to have been
- * created by apis in this module.
+ * All non-null arguments MUST have been created by created by apis in this module.
  */
+__attribute__((warn_unused_result))
 struct ddprof_ffi_SendResult ddprof_ffi_ProfileExporterV3_send(struct ddprof_ffi_ProfileExporterV3 *exporter,
-                                                               struct ddprof_ffi_Request *request);
+                                                               struct ddprof_ffi_Request *request,
+                                                               struct ddprof_ffi_CancellationToken *cancel);
+
+/**
+ * Can be passed as an argument to send and then be used to asynchronously cancel it from a different thread.
+ */
+__attribute__((warn_unused_result))
+struct ddprof_ffi_CancellationToken *ddprof_ffi_CancellationToken_new(void);
+
+/**
+ * A cloned CancellationToken is connected to the CancellationToken it was created from.
+ * Either the cloned or the original token can be used to cancel or provided as arguments to send.
+ * The useful part is that they have independent lifetimes and can be dropped separately.
+ *
+ * Thus, it's possible to do something like:
+ * ```c
+ * cancel_t1 = ddprof_ffi_CancellationToken_new();
+ * cancel_t2 = ddprof_ffi_CancellationToken_clone(cancel_t1);
+ *
+ * // On thread t1:
+ *     ddprof_ffi_ProfileExporterV3_send(..., cancel_t1);
+ *     ddprof_ffi_CancellationToken_drop(cancel_t1);
+ *
+ * // On thread t2:
+ *     ddprof_ffi_CancellationToken_cancel(cancel_t2);
+ *     ddprof_ffi_CancellationToken_drop(cancel_t2);
+ * ```
+ *
+ * Without clone, both t1 and t2 would need to synchronize to make sure neither was using the cancel
+ * before it could be dropped. With clone, there is no need for such synchronization, both threads
+ * have their own cancel and should drop that cancel after they are done with it.
+ */
+__attribute__((warn_unused_result))
+struct ddprof_ffi_CancellationToken *ddprof_ffi_CancellationToken_clone(struct ddprof_ffi_CancellationToken *cancel);
+
+/**
+ * Cancel send that is being called in another thread with the given token.
+ * Note that cancellation is a terminal state; cancelling a token more than once does nothing.
+ * Returns `true` if token was successfully cancelled.
+ */
+bool ddprof_ffi_CancellationToken_cancel(struct ddprof_ffi_CancellationToken *cancel);
+
+void ddprof_ffi_CancellationToken_drop(struct ddprof_ffi_CancellationToken *_cancel);
+
+void ddprof_ffi_SendResult_drop(struct ddprof_ffi_SendResult result);
 
 /**
  * Create a new profile with the given sample types. Must call
@@ -423,20 +510,16 @@ uint64_t ddprof_ffi_Profile_add(struct ddprof_ffi_Profile *profile,
                                 struct ddprof_ffi_Sample sample);
 
 /**
- * Destroys the `encoded_profile`
- * # Safety
- * Only safe on profiles created by `ddprof_ffi_Profile_serialize`.
+ * Serialize the aggregated profile. Don't forget to clean up the result by
+ * calling ddprof_ffi_SerializeResult_drop.
  */
-void ddprof_ffi_EncodedProfile_delete(struct ddprof_ffi_EncodedProfile *encoded_profile);
+__attribute__((warn_unused_result))
+struct ddprof_ffi_SerializeResult ddprof_ffi_Profile_serialize(const struct ddprof_ffi_Profile *profile);
+
+void ddprof_ffi_SerializeResult_drop(struct ddprof_ffi_SerializeResult result);
 
-/**
- * Serialize the aggregated profile. Be sure to check the return value and if
- * it's non-null then call `ddprof_ffi_EncodedProfile_delete` on it once
- * done with it.
- * result to free it.
- */
 __attribute__((warn_unused_result))
-struct ddprof_ffi_EncodedProfile *ddprof_ffi_Profile_serialize(const struct ddprof_ffi_Profile *profile);
+struct ddprof_ffi_Slice_u8 ddprof_ffi_Vec_u8_as_slice(const struct ddprof_ffi_Vec_u8 *vec);
 
 /**
  * Resets all data in `profile` except the sample types and period. Returns
@@ -445,11 +528,28 @@ struct ddprof_ffi_EncodedProfile *ddprof_ffi_Profile_serialize(const struct ddpr
  */
 bool ddprof_ffi_Profile_reset(struct ddprof_ffi_Profile *profile);
 
+__attribute__((warn_unused_result)) struct ddprof_ffi_Vec_tag ddprof_ffi_Vec_tag_new(void);
+
+void ddprof_ffi_Vec_tag_drop(struct ddprof_ffi_Vec_tag);
+
+void ddprof_ffi_PushTagResult_drop(struct ddprof_ffi_PushTagResult);
+
 /**
+ * Creates a new Tag from the provided `key` and `value` by doing a utf8
+ * lossy conversion, and pushes into the `vec`. The strings `key` and `value`
+ * are cloned to avoid FFI lifetime issues.
+ *
  * # Safety
- * Only pass buffers which were created by ddprof routines; do not create one
- * in C and then pass it in. Only call this once per buffer.
+ * The `vec` must be a valid reference.
+ * The CharSlices `key` and `value` must point to at least many bytes as their
+ * `.len` properties claim.
  */
-void ddprof_ffi_Buffer_free(struct ddprof_ffi_Buffer *buffer);
+__attribute__((warn_unused_result))
+struct ddprof_ffi_PushTagResult ddprof_ffi_Vec_tag_push(struct ddprof_ffi_Vec_tag *vec,
+                                                        ddprof_ffi_CharSlice key,
+                                                        ddprof_ffi_CharSlice value);
+
+__attribute__((warn_unused_result))
+struct ddprof_ffi_ParseTagsResult ddprof_ffi_Vec_tag_parse(ddprof_ffi_CharSlice string);
 
 #endif /* DDPROF_FFI_H */

data/vendor/{libddprof-0.5.0 → libddprof-0.6.0}/x86_64-linux/libddprof-x86_64-unknown-linux-gnu/lib/pkgconfig/ddprof_ffi_with_rpath.pc

@@ -10,7 +10,7 @@ includedir=${prefix}/include
 
 Name: ddprof_ffi
 Description: Contains common code used to implement Datadog's Continuous Profilers. (Dynamic linking variant, sets rpath)
-Version: 0.4.0-rc.1
+Version: 0.6.0
 Requires:
 Libs: -L${libdir} -lddprof_ffi -Wl,-rpath,${libdir}
 Libs.private: