LCOV - code coverage report
Current view: top level - libs/walproposer/src - api_bindings.rs (source / functions) Coverage Total Hit
Test: 1b0a6a0c05cee5a7de360813c8034804e105ce1c.info Lines: 93.0 % 399 371
Test Date: 2025-03-12 00:01:28 Functions: 94.6 % 37 35

            Line data    Source code
       1              : //! A C-Rust shim: defines implementation of C walproposer API, assuming wp
       2              : //! callback_data stores Box to some Rust implementation.
       3              : 
       4              : #![allow(dead_code)]
       5              : 
       6              : use std::ffi::{CStr, CString};
       7              : 
       8              : use crate::bindings::{
       9              :     NeonWALReadResult, PGAsyncReadResult, PGAsyncWriteResult, Safekeeper, Size, StringInfoData,
      10              :     TimestampTz, WalProposer, WalProposerConnStatusType, WalProposerConnectPollStatusType,
      11              :     WalProposerExecStatusType, WalproposerShmemState, XLogRecPtr, uint32, walproposer_api,
      12              : };
      13              : use crate::walproposer::{ApiImpl, StreamingCallback, WaitResult};
      14              : 
      15         1026 : extern "C" fn get_shmem_state(wp: *mut WalProposer) -> *mut WalproposerShmemState {
      16         1026 :     unsafe {
      17         1026 :         let callback_data = (*(*wp).config).callback_data;
      18         1026 :         let api = callback_data as *mut Box<dyn ApiImpl>;
      19         1026 :         (*api).get_shmem_state()
      20         1026 :     }
      21         1026 : }
      22              : 
      23          160 : extern "C-unwind" fn start_streaming(wp: *mut WalProposer, startpos: XLogRecPtr) {
      24          160 :     unsafe {
      25          160 :         let callback_data = (*(*wp).config).callback_data;
      26          160 :         let api = callback_data as *mut Box<dyn ApiImpl>;
      27          160 :         let callback = StreamingCallback::new(wp);
      28          160 :         (*api).start_streaming(startpos, &callback);
      29          160 :     }
      30          160 : }
      31              : 
      32          101 : extern "C" fn get_flush_rec_ptr(wp: *mut WalProposer) -> XLogRecPtr {
      33          101 :     unsafe {
      34          101 :         let callback_data = (*(*wp).config).callback_data;
      35          101 :         let api = callback_data as *mut Box<dyn ApiImpl>;
      36          101 :         (*api).get_flush_rec_ptr()
      37          101 :     }
      38          101 : }
      39              : 
      40          903 : extern "C" fn update_donor(wp: *mut WalProposer, donor: *mut Safekeeper, donor_lsn: XLogRecPtr) {
      41          903 :     unsafe {
      42          903 :         let callback_data = (*(*wp).config).callback_data;
      43          903 :         let api = callback_data as *mut Box<dyn ApiImpl>;
      44          903 :         (*api).update_donor(&mut (*donor), donor_lsn)
      45          903 :     }
      46          903 : }
      47              : 
      48       309370 : extern "C" fn get_current_timestamp(wp: *mut WalProposer) -> TimestampTz {
      49       309370 :     unsafe {
      50       309370 :         let callback_data = (*(*wp).config).callback_data;
      51       309370 :         let api = callback_data as *mut Box<dyn ApiImpl>;
      52       309370 :         (*api).get_current_timestamp()
      53       309370 :     }
      54       309370 : }
      55              : 
      56        10793 : extern "C" fn conn_error_message(sk: *mut Safekeeper) -> *mut ::std::os::raw::c_char {
      57        10793 :     unsafe {
      58        10793 :         let callback_data = (*(*(*sk).wp).config).callback_data;
      59        10793 :         let api = callback_data as *mut Box<dyn ApiImpl>;
      60        10793 :         let msg = (*api).conn_error_message(&mut (*sk));
      61        10793 :         let msg = CString::new(msg).unwrap();
      62        10793 :         // TODO: fix leaking error message
      63        10793 :         msg.into_raw()
      64        10793 :     }
      65        10793 : }
      66              : 
      67        32613 : extern "C" fn conn_status(sk: *mut Safekeeper) -> WalProposerConnStatusType {
      68        32613 :     unsafe {
      69        32613 :         let callback_data = (*(*(*sk).wp).config).callback_data;
      70        32613 :         let api = callback_data as *mut Box<dyn ApiImpl>;
      71        32613 :         (*api).conn_status(&mut (*sk))
      72        32613 :     }
      73        32613 : }
      74              : 
      75        32613 : extern "C" fn conn_connect_start(sk: *mut Safekeeper) {
      76        32613 :     unsafe {
      77        32613 :         let callback_data = (*(*(*sk).wp).config).callback_data;
      78        32613 :         let api = callback_data as *mut Box<dyn ApiImpl>;
      79        32613 :         (*api).conn_connect_start(&mut (*sk))
      80        32613 :     }
      81        32613 : }
      82              : 
      83        29408 : extern "C" fn conn_connect_poll(sk: *mut Safekeeper) -> WalProposerConnectPollStatusType {
      84        29408 :     unsafe {
      85        29408 :         let callback_data = (*(*(*sk).wp).config).callback_data;
      86        29408 :         let api = callback_data as *mut Box<dyn ApiImpl>;
      87        29408 :         (*api).conn_connect_poll(&mut (*sk))
      88        29408 :     }
      89        29408 : }
      90              : 
      91        29408 : extern "C" fn conn_send_query(sk: *mut Safekeeper, query: *mut ::std::os::raw::c_char) -> bool {
      92        29408 :     let query = unsafe { CStr::from_ptr(query) };
      93        29408 :     let query = query.to_str().unwrap();
      94        29408 : 
      95        29408 :     unsafe {
      96        29408 :         let callback_data = (*(*(*sk).wp).config).callback_data;
      97        29408 :         let api = callback_data as *mut Box<dyn ApiImpl>;
      98        29408 :         (*api).conn_send_query(&mut (*sk), query)
      99        29408 :     }
     100        29408 : }
     101              : 
     102        29408 : extern "C" fn conn_get_query_result(sk: *mut Safekeeper) -> WalProposerExecStatusType {
     103        29408 :     unsafe {
     104        29408 :         let callback_data = (*(*(*sk).wp).config).callback_data;
     105        29408 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     106        29408 :         (*api).conn_get_query_result(&mut (*sk))
     107        29408 :     }
     108        29408 : }
     109              : 
     110            0 : extern "C" fn conn_flush(sk: *mut Safekeeper) -> ::std::os::raw::c_int {
     111            0 :     unsafe {
     112            0 :         let callback_data = (*(*(*sk).wp).config).callback_data;
     113            0 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     114            0 :         (*api).conn_flush(&mut (*sk))
     115            0 :     }
     116            0 : }
     117              : 
     118        11050 : extern "C" fn conn_finish(sk: *mut Safekeeper) {
     119        11050 :     unsafe {
     120        11050 :         let callback_data = (*(*(*sk).wp).config).callback_data;
     121        11050 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     122        11050 :         (*api).conn_finish(&mut (*sk))
     123        11050 :     }
     124        11050 : }
     125              : 
     126        17762 : extern "C" fn conn_async_read(
     127        17762 :     sk: *mut Safekeeper,
     128        17762 :     buf: *mut *mut ::std::os::raw::c_char,
     129        17762 :     amount: *mut ::std::os::raw::c_int,
     130        17762 : ) -> PGAsyncReadResult {
     131        17762 :     unsafe {
     132        17762 :         let callback_data = (*(*(*sk).wp).config).callback_data;
     133        17762 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     134        17762 : 
     135        17762 :         // This function has guarantee that returned buf will be valid until
     136        17762 :         // the next call. So we can store a Vec in each Safekeeper and reuse
     137        17762 :         // it on the next call.
     138        17762 :         let mut inbuf = take_vec_u8(&mut (*sk).inbuf).unwrap_or_default();
     139        17762 :         inbuf.clear();
     140        17762 : 
     141        17762 :         let result = (*api).conn_async_read(&mut (*sk), &mut inbuf);
     142        17762 : 
     143        17762 :         // Put a Vec back to sk->inbuf and return data ptr.
     144        17762 :         *amount = inbuf.len() as i32;
     145        17762 :         *buf = store_vec_u8(&mut (*sk).inbuf, inbuf);
     146        17762 : 
     147        17762 :         result
     148        17762 :     }
     149        17762 : }
     150              : 
     151         4880 : extern "C" fn conn_async_write(
     152         4880 :     sk: *mut Safekeeper,
     153         4880 :     buf: *const ::std::os::raw::c_void,
     154         4880 :     size: usize,
     155         4880 : ) -> PGAsyncWriteResult {
     156         4880 :     unsafe {
     157         4880 :         let buf = std::slice::from_raw_parts(buf as *const u8, size);
     158         4880 :         let callback_data = (*(*(*sk).wp).config).callback_data;
     159         4880 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     160         4880 :         (*api).conn_async_write(&mut (*sk), buf)
     161         4880 :     }
     162         4880 : }
     163              : 
     164        32662 : extern "C" fn conn_blocking_write(
     165        32662 :     sk: *mut Safekeeper,
     166        32662 :     buf: *const ::std::os::raw::c_void,
     167        32662 :     size: usize,
     168        32662 : ) -> bool {
     169        32662 :     unsafe {
     170        32662 :         let buf = std::slice::from_raw_parts(buf as *const u8, size);
     171        32662 :         let callback_data = (*(*(*sk).wp).config).callback_data;
     172        32662 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     173        32662 :         (*api).conn_blocking_write(&mut (*sk), buf)
     174        32662 :     }
     175        32662 : }
     176              : 
     177          513 : extern "C-unwind" fn recovery_download(wp: *mut WalProposer, sk: *mut Safekeeper) -> bool {
     178          513 :     unsafe {
     179          513 :         let callback_data = (*(*(*sk).wp).config).callback_data;
     180          513 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     181          513 : 
     182          513 :         // currently `recovery_download` is always called right after election
     183          513 :         (*api).after_election(&mut (*wp));
     184          513 : 
     185          513 :         (*api).recovery_download(&mut (*wp), &mut (*sk))
     186          513 :     }
     187          513 : }
     188              : 
     189          948 : extern "C" fn wal_reader_allocate(sk: *mut Safekeeper) {
     190          948 :     unsafe {
     191          948 :         let callback_data = (*(*(*sk).wp).config).callback_data;
     192          948 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     193          948 :         (*api).wal_reader_allocate(&mut (*sk));
     194          948 :     }
     195          948 : }
     196              : 
     197              : #[allow(clippy::unnecessary_cast)]
     198          918 : extern "C" fn wal_read(
     199          918 :     sk: *mut Safekeeper,
     200          918 :     buf: *mut ::std::os::raw::c_char,
     201          918 :     startptr: XLogRecPtr,
     202          918 :     count: Size,
     203          918 :     _errmsg: *mut *mut ::std::os::raw::c_char,
     204          918 : ) -> NeonWALReadResult {
     205          918 :     unsafe {
     206          918 :         let buf = std::slice::from_raw_parts_mut(buf as *mut u8, count);
     207          918 :         let callback_data = (*(*(*sk).wp).config).callback_data;
     208          918 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     209          918 :         // TODO: errmsg is not forwarded
     210          918 :         (*api).wal_read(&mut (*sk), buf, startptr)
     211          918 :     }
     212          918 : }
     213              : 
     214        16787 : extern "C" fn wal_reader_events(sk: *mut Safekeeper) -> uint32 {
     215        16787 :     unsafe {
     216        16787 :         let callback_data = (*(*(*sk).wp).config).callback_data;
     217        16787 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     218        16787 :         (*api).wal_reader_events(&mut (*sk))
     219        16787 :     }
     220        16787 : }
     221              : 
     222         8793 : extern "C" fn init_event_set(wp: *mut WalProposer) {
     223         8793 :     unsafe {
     224         8793 :         let callback_data = (*(*wp).config).callback_data;
     225         8793 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     226         8793 :         (*api).init_event_set(&mut (*wp));
     227         8793 :     }
     228         8793 : }
     229              : 
     230        63876 : extern "C" fn update_event_set(sk: *mut Safekeeper, events: uint32) {
     231        63876 :     unsafe {
     232        63876 :         let callback_data = (*(*(*sk).wp).config).callback_data;
     233        63876 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     234        63876 :         (*api).update_event_set(&mut (*sk), events);
     235        63876 :     }
     236        63876 : }
     237              : 
     238         6058 : extern "C" fn active_state_update_event_set(sk: *mut Safekeeper) {
     239         6058 :     unsafe {
     240         6058 :         let callback_data = (*(*(*sk).wp).config).callback_data;
     241         6058 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     242         6058 :         (*api).active_state_update_event_set(&mut (*sk));
     243         6058 :     }
     244         6058 : }
     245              : 
     246        58816 : extern "C" fn add_safekeeper_event_set(sk: *mut Safekeeper, events: uint32) {
     247        58816 :     unsafe {
     248        58816 :         let callback_data = (*(*(*sk).wp).config).callback_data;
     249        58816 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     250        58816 :         (*api).add_safekeeper_event_set(&mut (*sk), events);
     251        58816 :     }
     252        58816 : }
     253              : 
     254        37253 : extern "C" fn rm_safekeeper_event_set(sk: *mut Safekeeper) {
     255        37253 :     unsafe {
     256        37253 :         let callback_data = (*(*(*sk).wp).config).callback_data;
     257        37253 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     258        37253 :         (*api).rm_safekeeper_event_set(&mut (*sk));
     259        37253 :     }
     260        37253 : }
     261              : 
     262        86237 : extern "C-unwind" fn wait_event_set(
     263        86237 :     wp: *mut WalProposer,
     264        86237 :     timeout: ::std::os::raw::c_long,
     265        86237 :     event_sk: *mut *mut Safekeeper,
     266        86237 :     events: *mut uint32,
     267        86237 : ) -> ::std::os::raw::c_int {
     268        86237 :     unsafe {
     269        86237 :         let callback_data = (*(*wp).config).callback_data;
     270        86237 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     271        86237 :         let result = (*api).wait_event_set(&mut (*wp), timeout);
     272        86237 :         match result {
     273              :             WaitResult::Latch => {
     274         8860 :                 *event_sk = std::ptr::null_mut();
     275         8860 :                 *events = crate::bindings::WL_LATCH_SET;
     276         8860 :                 1
     277              :             }
     278              :             WaitResult::Timeout => {
     279         2773 :                 *event_sk = std::ptr::null_mut();
     280         2773 :                 // WaitEventSetWait returns 0 for timeout.
     281         2773 :                 *events = 0;
     282         2773 :                 0
     283              :             }
     284        74604 :             WaitResult::Network(sk, event_mask) => {
     285        74604 :                 *event_sk = sk;
     286        74604 :                 *events = event_mask;
     287        74604 :                 1
     288              :             }
     289              :         }
     290              :     }
     291        86237 : }
     292              : 
     293            0 : extern "C" fn strong_random(
     294            0 :     wp: *mut WalProposer,
     295            0 :     buf: *mut ::std::os::raw::c_void,
     296            0 :     len: usize,
     297            0 : ) -> bool {
     298            0 :     unsafe {
     299            0 :         let buf = std::slice::from_raw_parts_mut(buf as *mut u8, len);
     300            0 :         let callback_data = (*(*wp).config).callback_data;
     301            0 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     302            0 :         (*api).strong_random(buf)
     303            0 :     }
     304            0 : }
     305              : 
     306          213 : extern "C" fn get_redo_start_lsn(wp: *mut WalProposer) -> XLogRecPtr {
     307          213 :     unsafe {
     308          213 :         let callback_data = (*(*wp).config).callback_data;
     309          213 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     310          213 :         (*api).get_redo_start_lsn()
     311          213 :     }
     312          213 : }
     313              : 
     314          326 : extern "C-unwind" fn finish_sync_safekeepers(wp: *mut WalProposer, lsn: XLogRecPtr) {
     315          326 :     unsafe {
     316          326 :         let callback_data = (*(*wp).config).callback_data;
     317          326 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     318          326 :         (*api).finish_sync_safekeepers(lsn)
     319          326 :     }
     320          326 : }
     321              : 
     322         2286 : extern "C" fn process_safekeeper_feedback(wp: *mut WalProposer, sk: *mut Safekeeper) {
     323         2286 :     unsafe {
     324         2286 :         let callback_data = (*(*wp).config).callback_data;
     325         2286 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     326         2286 :         (*api).process_safekeeper_feedback(&mut (*wp), &mut (*sk));
     327         2286 :     }
     328         2286 : }
     329              : 
     330       144082 : extern "C-unwind" fn log_internal(
     331       144082 :     wp: *mut WalProposer,
     332       144082 :     level: ::std::os::raw::c_int,
     333       144082 :     line: *const ::std::os::raw::c_char,
     334       144082 : ) {
     335       144082 :     unsafe {
     336       144082 :         let callback_data = (*(*wp).config).callback_data;
     337       144082 :         let api = callback_data as *mut Box<dyn ApiImpl>;
     338       144082 :         let line = CStr::from_ptr(line);
     339       144082 :         let line = line.to_str().unwrap();
     340       144082 :         (*api).log_internal(&mut (*wp), Level::from(level as u32), line)
     341       144082 :     }
     342       144082 : }
     343              : 
     344              : #[derive(Debug, PartialEq)]
     345              : pub enum Level {
     346              :     Debug5,
     347              :     Debug4,
     348              :     Debug3,
     349              :     Debug2,
     350              :     Debug1,
     351              :     Log,
     352              :     Info,
     353              :     Notice,
     354              :     Warning,
     355              :     Error,
     356              :     Fatal,
     357              :     Panic,
     358              :     WPEvent,
     359              : }
     360              : 
     361              : impl Level {
     362       144082 :     pub fn from(elevel: u32) -> Level {
     363              :         use crate::bindings::*;
     364              : 
     365       144082 :         match elevel {
     366         3932 :             DEBUG5 => Level::Debug5,
     367            0 :             DEBUG4 => Level::Debug4,
     368            0 :             DEBUG3 => Level::Debug3,
     369         2286 :             DEBUG2 => Level::Debug2,
     370            0 :             DEBUG1 => Level::Debug1,
     371       126729 :             LOG => Level::Log,
     372            0 :             INFO => Level::Info,
     373            0 :             NOTICE => Level::Notice,
     374        11095 :             WARNING => Level::Warning,
     375            0 :             ERROR => Level::Error,
     376           40 :             FATAL => Level::Fatal,
     377            0 :             PANIC => Level::Panic,
     378            0 :             WPEVENT => Level::WPEvent,
     379            0 :             _ => panic!("unknown log level {}", elevel),
     380              :         }
     381       144082 :     }
     382              : }
     383              : 
     384         8793 : pub(crate) fn create_api() -> walproposer_api {
     385         8793 :     walproposer_api {
     386         8793 :         get_shmem_state: Some(get_shmem_state),
     387         8793 :         start_streaming: Some(start_streaming),
     388         8793 :         get_flush_rec_ptr: Some(get_flush_rec_ptr),
     389         8793 :         update_donor: Some(update_donor),
     390         8793 :         get_current_timestamp: Some(get_current_timestamp),
     391         8793 :         conn_error_message: Some(conn_error_message),
     392         8793 :         conn_status: Some(conn_status),
     393         8793 :         conn_connect_start: Some(conn_connect_start),
     394         8793 :         conn_connect_poll: Some(conn_connect_poll),
     395         8793 :         conn_send_query: Some(conn_send_query),
     396         8793 :         conn_get_query_result: Some(conn_get_query_result),
     397         8793 :         conn_flush: Some(conn_flush),
     398         8793 :         conn_finish: Some(conn_finish),
     399         8793 :         conn_async_read: Some(conn_async_read),
     400         8793 :         conn_async_write: Some(conn_async_write),
     401         8793 :         conn_blocking_write: Some(conn_blocking_write),
     402         8793 :         recovery_download: Some(recovery_download),
     403         8793 :         wal_reader_allocate: Some(wal_reader_allocate),
     404         8793 :         wal_read: Some(wal_read),
     405         8793 :         wal_reader_events: Some(wal_reader_events),
     406         8793 :         init_event_set: Some(init_event_set),
     407         8793 :         update_event_set: Some(update_event_set),
     408         8793 :         active_state_update_event_set: Some(active_state_update_event_set),
     409         8793 :         add_safekeeper_event_set: Some(add_safekeeper_event_set),
     410         8793 :         rm_safekeeper_event_set: Some(rm_safekeeper_event_set),
     411         8793 :         wait_event_set: Some(wait_event_set),
     412         8793 :         strong_random: Some(strong_random),
     413         8793 :         get_redo_start_lsn: Some(get_redo_start_lsn),
     414         8793 :         finish_sync_safekeepers: Some(finish_sync_safekeepers),
     415         8793 :         process_safekeeper_feedback: Some(process_safekeeper_feedback),
     416         8793 :         log_internal: Some(log_internal),
     417         8793 :     }
     418         8793 : }
     419              : 
     420         8793 : pub fn empty_shmem() -> crate::bindings::WalproposerShmemState {
     421         8793 :     let empty_feedback = crate::bindings::PageserverFeedback {
     422         8793 :         present: false,
     423         8793 :         currentClusterSize: 0,
     424         8793 :         last_received_lsn: 0,
     425         8793 :         disk_consistent_lsn: 0,
     426         8793 :         remote_consistent_lsn: 0,
     427         8793 :         replytime: 0,
     428         8793 :         shard_number: 0,
     429         8793 :     };
     430         8793 : 
     431         8793 :     crate::bindings::WalproposerShmemState {
     432         8793 :         propEpochStartLsn: crate::bindings::pg_atomic_uint64 { value: 0 },
     433         8793 :         donor_name: [0; 64],
     434         8793 :         donor_conninfo: [0; 1024],
     435         8793 :         donor_lsn: 0,
     436         8793 :         mutex: 0,
     437         8793 :         mineLastElectedTerm: crate::bindings::pg_atomic_uint64 { value: 0 },
     438         8793 :         backpressureThrottlingTime: crate::bindings::pg_atomic_uint64 { value: 0 },
     439         8793 :         currentClusterSize: crate::bindings::pg_atomic_uint64 { value: 0 },
     440         8793 :         shard_ps_feedback: [empty_feedback; 128],
     441         8793 :         num_shards: 0,
     442         8793 :         min_ps_feedback: empty_feedback,
     443         8793 :     }
     444         8793 : }
     445              : 
     446              : impl std::fmt::Display for Level {
     447         1533 :     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
     448         1533 :         write!(f, "{:?}", self)
     449         1533 :     }
     450              : }
     451              : 
     452              : /// Take ownership of `Vec<u8>` from StringInfoData.
     453              : #[allow(clippy::unnecessary_cast)]
     454        44133 : pub(crate) fn take_vec_u8(pg: &mut StringInfoData) -> Option<Vec<u8>> {
     455        44133 :     if pg.data.is_null() {
     456        26376 :         return None;
     457        17757 :     }
     458        17757 : 
     459        17757 :     let ptr = pg.data as *mut u8;
     460        17757 :     let length = pg.len as usize;
     461        17757 :     let capacity = pg.maxlen as usize;
     462        17757 : 
     463        17757 :     pg.data = std::ptr::null_mut();
     464        17757 :     pg.len = 0;
     465        17757 :     pg.maxlen = 0;
     466        17757 : 
     467        17757 :     unsafe { Some(Vec::from_raw_parts(ptr, length, capacity)) }
     468        44133 : }
     469              : 
     470              : /// Store `Vec<u8>` in StringInfoData.
     471        17762 : fn store_vec_u8(pg: &mut StringInfoData, vec: Vec<u8>) -> *mut ::std::os::raw::c_char {
     472        17762 :     let ptr = vec.as_ptr() as *mut ::std::os::raw::c_char;
     473        17762 :     let length = vec.len();
     474        17762 :     let capacity = vec.capacity();
     475        17762 : 
     476        17762 :     assert!(pg.data.is_null());
     477              : 
     478        17762 :     pg.data = ptr;
     479        17762 :     pg.len = length as i32;
     480        17762 :     pg.maxlen = capacity as i32;
     481        17762 : 
     482        17762 :     std::mem::forget(vec);
     483        17762 : 
     484        17762 :     ptr
     485        17762 : }
        

Generated by: LCOV version 2.1-beta