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

Generated by: LCOV version 2.1-beta