LCOV - code coverage report
Current view: top level - libs/walproposer/src - api_bindings.rs (source / functions) Coverage Total Hit
Test: 07bee600374ccd486c69370d0972d9035964fe68.info Lines: 96.2 % 399 384
Test Date: 2025-02-20 13:11:02 Functions: 97.3 % 37 36

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

Generated by: LCOV version 2.1-beta