LCOV - code coverage report
Current view: top level - src/backend/tcop - fastpath.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 91 131 69.5 %
Date: 2024-03-28 14:11:12 Functions: 4 4 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * fastpath.c
       4             :  *    routines to handle function requests from the frontend
       5             :  *
       6             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/tcop/fastpath.c
      12             :  *
      13             :  * NOTES
      14             :  *    This cruft is the server side of PQfn.
      15             :  *
      16             :  *-------------------------------------------------------------------------
      17             :  */
      18             : #include "postgres.h"
      19             : 
      20             : #include "access/htup_details.h"
      21             : #include "access/xact.h"
      22             : #include "catalog/objectaccess.h"
      23             : #include "catalog/pg_namespace.h"
      24             : #include "catalog/pg_proc.h"
      25             : #include "libpq/pqformat.h"
      26             : #include "libpq/protocol.h"
      27             : #include "mb/pg_wchar.h"
      28             : #include "miscadmin.h"
      29             : #include "port/pg_bswap.h"
      30             : #include "tcop/fastpath.h"
      31             : #include "tcop/tcopprot.h"
      32             : #include "utils/acl.h"
      33             : #include "utils/lsyscache.h"
      34             : #include "utils/snapmgr.h"
      35             : #include "utils/syscache.h"
      36             : 
      37             : 
      38             : /*
      39             :  * Formerly, this code attempted to cache the function and type info
      40             :  * looked up by fetch_fp_info, but only for the duration of a single
      41             :  * transaction command (since in theory the info could change between
      42             :  * commands).  This was utterly useless, because postgres.c executes
      43             :  * each fastpath call as a separate transaction command, and so the
      44             :  * cached data could never actually have been reused.  If it had worked
      45             :  * as intended, it would have had problems anyway with dangling references
      46             :  * in the FmgrInfo struct.  So, forget about caching and just repeat the
      47             :  * syscache fetches on each usage.  They're not *that* expensive.
      48             :  */
      49             : struct fp_info
      50             : {
      51             :     Oid         funcid;
      52             :     FmgrInfo    flinfo;         /* function lookup info for funcid */
      53             :     Oid         namespace;      /* other stuff from pg_proc */
      54             :     Oid         rettype;
      55             :     Oid         argtypes[FUNC_MAX_ARGS];
      56             :     char        fname[NAMEDATALEN]; /* function name for logging */
      57             : };
      58             : 
      59             : 
      60             : static int16 parse_fcall_arguments(StringInfo msgBuf, struct fp_info *fip,
      61             :                                    FunctionCallInfo fcinfo);
      62             : 
      63             : /* ----------------
      64             :  *      SendFunctionResult
      65             :  * ----------------
      66             :  */
      67             : static void
      68        2084 : SendFunctionResult(Datum retval, bool isnull, Oid rettype, int16 format)
      69             : {
      70             :     StringInfoData buf;
      71             : 
      72        2084 :     pq_beginmessage(&buf, PqMsg_FunctionCallResponse);
      73             : 
      74        2084 :     if (isnull)
      75             :     {
      76           0 :         pq_sendint32(&buf, -1);
      77             :     }
      78             :     else
      79             :     {
      80        2084 :         if (format == 0)
      81             :         {
      82             :             Oid         typoutput;
      83             :             bool        typisvarlena;
      84             :             char       *outputstr;
      85             : 
      86           0 :             getTypeOutputInfo(rettype, &typoutput, &typisvarlena);
      87           0 :             outputstr = OidOutputFunctionCall(typoutput, retval);
      88           0 :             pq_sendcountedtext(&buf, outputstr, strlen(outputstr));
      89           0 :             pfree(outputstr);
      90             :         }
      91        2084 :         else if (format == 1)
      92             :         {
      93             :             Oid         typsend;
      94             :             bool        typisvarlena;
      95             :             bytea      *outputbytes;
      96             : 
      97        2084 :             getTypeBinaryOutputInfo(rettype, &typsend, &typisvarlena);
      98        2084 :             outputbytes = OidSendFunctionCall(typsend, retval);
      99        2084 :             pq_sendint32(&buf, VARSIZE(outputbytes) - VARHDRSZ);
     100        2084 :             pq_sendbytes(&buf, VARDATA(outputbytes),
     101        2084 :                          VARSIZE(outputbytes) - VARHDRSZ);
     102        2084 :             pfree(outputbytes);
     103             :         }
     104             :         else
     105           0 :             ereport(ERROR,
     106             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     107             :                      errmsg("unsupported format code: %d", format)));
     108             :     }
     109             : 
     110        2084 :     pq_endmessage(&buf);
     111        2084 : }
     112             : 
     113             : /*
     114             :  * fetch_fp_info
     115             :  *
     116             :  * Performs catalog lookups to load a struct fp_info 'fip' for the
     117             :  * function 'func_id'.
     118             :  */
     119             : static void
     120        2084 : fetch_fp_info(Oid func_id, struct fp_info *fip)
     121             : {
     122             :     HeapTuple   func_htp;
     123             :     Form_pg_proc pp;
     124             : 
     125             :     Assert(fip != NULL);
     126             : 
     127             :     /*
     128             :      * Since the validity of this structure is determined by whether the
     129             :      * funcid is OK, we clear the funcid here.  It must not be set to the
     130             :      * correct value until we are about to return with a good struct fp_info,
     131             :      * since we can be interrupted (i.e., with an ereport(ERROR, ...)) at any
     132             :      * time.  [No longer really an issue since we don't save the struct
     133             :      * fp_info across transactions anymore, but keep it anyway.]
     134             :      */
     135      139628 :     MemSet(fip, 0, sizeof(struct fp_info));
     136        2084 :     fip->funcid = InvalidOid;
     137             : 
     138        2084 :     func_htp = SearchSysCache1(PROCOID, ObjectIdGetDatum(func_id));
     139        2084 :     if (!HeapTupleIsValid(func_htp))
     140           0 :         ereport(ERROR,
     141             :                 (errcode(ERRCODE_UNDEFINED_FUNCTION),
     142             :                  errmsg("function with OID %u does not exist", func_id)));
     143        2084 :     pp = (Form_pg_proc) GETSTRUCT(func_htp);
     144             : 
     145             :     /* reject pg_proc entries that are unsafe to call via fastpath */
     146        2084 :     if (pp->prokind != PROKIND_FUNCTION || pp->proretset)
     147           0 :         ereport(ERROR,
     148             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     149             :                  errmsg("cannot call function \"%s\" via fastpath interface",
     150             :                         NameStr(pp->proname))));
     151             : 
     152             :     /* watch out for catalog entries with more than FUNC_MAX_ARGS args */
     153        2084 :     if (pp->pronargs > FUNC_MAX_ARGS)
     154           0 :         elog(ERROR, "function %s has more than %d arguments",
     155             :              NameStr(pp->proname), FUNC_MAX_ARGS);
     156             : 
     157        2084 :     fip->namespace = pp->pronamespace;
     158        2084 :     fip->rettype = pp->prorettype;
     159        2084 :     memcpy(fip->argtypes, pp->proargtypes.values, pp->pronargs * sizeof(Oid));
     160        2084 :     strlcpy(fip->fname, NameStr(pp->proname), NAMEDATALEN);
     161             : 
     162        2084 :     ReleaseSysCache(func_htp);
     163             : 
     164        2084 :     fmgr_info(func_id, &fip->flinfo);
     165             : 
     166             :     /*
     167             :      * This must be last!
     168             :      */
     169        2084 :     fip->funcid = func_id;
     170        2084 : }
     171             : 
     172             : 
     173             : /*
     174             :  * HandleFunctionRequest
     175             :  *
     176             :  * Server side of PQfn (fastpath function calls from the frontend).
     177             :  * This corresponds to the libpq protocol symbol "F".
     178             :  *
     179             :  * INPUT:
     180             :  *      postgres.c has already read the message body and will pass it in
     181             :  *      msgBuf.
     182             :  *
     183             :  * Note: palloc()s done here and in the called function do not need to be
     184             :  * cleaned up explicitly.  We are called from PostgresMain() in the
     185             :  * MessageContext memory context, which will be automatically reset when
     186             :  * control returns to PostgresMain.
     187             :  */
     188             : void
     189        2084 : HandleFunctionRequest(StringInfo msgBuf)
     190             : {
     191        2084 :     LOCAL_FCINFO(fcinfo, FUNC_MAX_ARGS);
     192             :     Oid         fid;
     193             :     AclResult   aclresult;
     194             :     int16       rformat;
     195             :     Datum       retval;
     196             :     struct fp_info my_fp;
     197             :     struct fp_info *fip;
     198             :     bool        callit;
     199        2084 :     bool        was_logged = false;
     200             :     char        msec_str[32];
     201             : 
     202             :     /*
     203             :      * We only accept COMMIT/ABORT if we are in an aborted transaction, and
     204             :      * COMMIT/ABORT cannot be executed through the fastpath interface.
     205             :      */
     206        2084 :     if (IsAbortedTransactionBlockState())
     207           0 :         ereport(ERROR,
     208             :                 (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
     209             :                  errmsg("current transaction is aborted, "
     210             :                         "commands ignored until end of transaction block")));
     211             : 
     212             :     /*
     213             :      * Now that we know we are in a valid transaction, set snapshot in case
     214             :      * needed by function itself or one of the datatype I/O routines.
     215             :      */
     216        2084 :     PushActiveSnapshot(GetTransactionSnapshot());
     217             : 
     218             :     /*
     219             :      * Begin parsing the buffer contents.
     220             :      */
     221        2084 :     fid = (Oid) pq_getmsgint(msgBuf, 4);    /* function oid */
     222             : 
     223             :     /*
     224             :      * There used to be a lame attempt at caching lookup info here. Now we
     225             :      * just do the lookups on every call.
     226             :      */
     227        2084 :     fip = &my_fp;
     228        2084 :     fetch_fp_info(fid, fip);
     229             : 
     230             :     /* Log as soon as we have the function OID and name */
     231        2084 :     if (log_statement == LOGSTMT_ALL)
     232             :     {
     233        1566 :         ereport(LOG,
     234             :                 (errmsg("fastpath function call: \"%s\" (OID %u)",
     235             :                         fip->fname, fid)));
     236        1566 :         was_logged = true;
     237             :     }
     238             : 
     239             :     /*
     240             :      * Check permission to access and call function.  Since we didn't go
     241             :      * through a normal name lookup, we need to check schema usage too.
     242             :      */
     243        2084 :     aclresult = object_aclcheck(NamespaceRelationId, fip->namespace, GetUserId(), ACL_USAGE);
     244        2084 :     if (aclresult != ACLCHECK_OK)
     245           0 :         aclcheck_error(aclresult, OBJECT_SCHEMA,
     246           0 :                        get_namespace_name(fip->namespace));
     247        2084 :     InvokeNamespaceSearchHook(fip->namespace, true);
     248             : 
     249        2084 :     aclresult = object_aclcheck(ProcedureRelationId, fid, GetUserId(), ACL_EXECUTE);
     250        2084 :     if (aclresult != ACLCHECK_OK)
     251           0 :         aclcheck_error(aclresult, OBJECT_FUNCTION,
     252           0 :                        get_func_name(fid));
     253        2084 :     InvokeFunctionExecuteHook(fid);
     254             : 
     255             :     /*
     256             :      * Prepare function call info block and insert arguments.
     257             :      *
     258             :      * Note: for now we pass collation = InvalidOid, so collation-sensitive
     259             :      * functions can't be called this way.  Perhaps we should pass
     260             :      * DEFAULT_COLLATION_OID, instead?
     261             :      */
     262        2084 :     InitFunctionCallInfoData(*fcinfo, &fip->flinfo, 0, InvalidOid, NULL, NULL);
     263             : 
     264        2084 :     rformat = parse_fcall_arguments(msgBuf, fip, fcinfo);
     265             : 
     266             :     /* Verify we reached the end of the message where expected. */
     267        2084 :     pq_getmsgend(msgBuf);
     268             : 
     269             :     /*
     270             :      * If func is strict, must not call it for null args.
     271             :      */
     272        2084 :     callit = true;
     273        2084 :     if (fip->flinfo.fn_strict)
     274             :     {
     275             :         int         i;
     276             : 
     277        6046 :         for (i = 0; i < fcinfo->nargs; i++)
     278             :         {
     279        3962 :             if (fcinfo->args[i].isnull)
     280             :             {
     281           0 :                 callit = false;
     282           0 :                 break;
     283             :             }
     284             :         }
     285             :     }
     286             : 
     287        2084 :     if (callit)
     288             :     {
     289             :         /* Okay, do it ... */
     290        2084 :         retval = FunctionCallInvoke(fcinfo);
     291             :     }
     292             :     else
     293             :     {
     294           0 :         fcinfo->isnull = true;
     295           0 :         retval = (Datum) 0;
     296             :     }
     297             : 
     298             :     /* ensure we do at least one CHECK_FOR_INTERRUPTS per function call */
     299        2084 :     CHECK_FOR_INTERRUPTS();
     300             : 
     301        2084 :     SendFunctionResult(retval, fcinfo->isnull, fip->rettype, rformat);
     302             : 
     303             :     /* We no longer need the snapshot */
     304        2084 :     PopActiveSnapshot();
     305             : 
     306             :     /*
     307             :      * Emit duration logging if appropriate.
     308             :      */
     309        2084 :     switch (check_log_duration(msec_str, was_logged))
     310             :     {
     311           0 :         case 1:
     312           0 :             ereport(LOG,
     313             :                     (errmsg("duration: %s ms", msec_str)));
     314           0 :             break;
     315           0 :         case 2:
     316           0 :             ereport(LOG,
     317             :                     (errmsg("duration: %s ms  fastpath function call: \"%s\" (OID %u)",
     318             :                             msec_str, fip->fname, fid)));
     319           0 :             break;
     320             :     }
     321        2084 : }
     322             : 
     323             : /*
     324             :  * Parse function arguments in a 3.0 protocol message
     325             :  *
     326             :  * Argument values are loaded into *fcinfo, and the desired result format
     327             :  * is returned.
     328             :  */
     329             : static int16
     330        2084 : parse_fcall_arguments(StringInfo msgBuf, struct fp_info *fip,
     331             :                       FunctionCallInfo fcinfo)
     332             : {
     333             :     int         nargs;
     334             :     int         i;
     335             :     int         numAFormats;
     336        2084 :     int16      *aformats = NULL;
     337             :     StringInfoData abuf;
     338             : 
     339             :     /* Get the argument format codes */
     340        2084 :     numAFormats = pq_getmsgint(msgBuf, 2);
     341        2084 :     if (numAFormats > 0)
     342             :     {
     343        2084 :         aformats = (int16 *) palloc(numAFormats * sizeof(int16));
     344        4168 :         for (i = 0; i < numAFormats; i++)
     345        2084 :             aformats[i] = pq_getmsgint(msgBuf, 2);
     346             :     }
     347             : 
     348        2084 :     nargs = pq_getmsgint(msgBuf, 2);    /* # of arguments */
     349             : 
     350        2084 :     if (fip->flinfo.fn_nargs != nargs || nargs > FUNC_MAX_ARGS)
     351           0 :         ereport(ERROR,
     352             :                 (errcode(ERRCODE_PROTOCOL_VIOLATION),
     353             :                  errmsg("function call message contains %d arguments but function requires %d",
     354             :                         nargs, fip->flinfo.fn_nargs)));
     355             : 
     356        2084 :     fcinfo->nargs = nargs;
     357             : 
     358        2084 :     if (numAFormats > 1 && numAFormats != nargs)
     359           0 :         ereport(ERROR,
     360             :                 (errcode(ERRCODE_PROTOCOL_VIOLATION),
     361             :                  errmsg("function call message contains %d argument formats but %d arguments",
     362             :                         numAFormats, nargs)));
     363             : 
     364        2084 :     initStringInfo(&abuf);
     365             : 
     366             :     /*
     367             :      * Copy supplied arguments into arg vector.
     368             :      */
     369        6046 :     for (i = 0; i < nargs; ++i)
     370             :     {
     371             :         int         argsize;
     372             :         int16       aformat;
     373             : 
     374        3962 :         argsize = pq_getmsgint(msgBuf, 4);
     375        3962 :         if (argsize == -1)
     376             :         {
     377           0 :             fcinfo->args[i].isnull = true;
     378             :         }
     379             :         else
     380             :         {
     381        3962 :             fcinfo->args[i].isnull = false;
     382        3962 :             if (argsize < 0)
     383           0 :                 ereport(ERROR,
     384             :                         (errcode(ERRCODE_PROTOCOL_VIOLATION),
     385             :                          errmsg("invalid argument size %d in function call message",
     386             :                                 argsize)));
     387             : 
     388             :             /* Reset abuf to empty, and insert raw data into it */
     389        3962 :             resetStringInfo(&abuf);
     390        3962 :             appendBinaryStringInfo(&abuf,
     391        3962 :                                    pq_getmsgbytes(msgBuf, argsize),
     392             :                                    argsize);
     393             :         }
     394             : 
     395        3962 :         if (numAFormats > 1)
     396           0 :             aformat = aformats[i];
     397        3962 :         else if (numAFormats > 0)
     398        3962 :             aformat = aformats[0];
     399             :         else
     400           0 :             aformat = 0;        /* default = text */
     401             : 
     402        3962 :         if (aformat == 0)
     403             :         {
     404             :             Oid         typinput;
     405             :             Oid         typioparam;
     406             :             char       *pstring;
     407             : 
     408           0 :             getTypeInputInfo(fip->argtypes[i], &typinput, &typioparam);
     409             : 
     410             :             /*
     411             :              * Since stringinfo.c keeps a trailing null in place even for
     412             :              * binary data, the contents of abuf are a valid C string.  We
     413             :              * have to do encoding conversion before calling the typinput
     414             :              * routine, though.
     415             :              */
     416           0 :             if (argsize == -1)
     417           0 :                 pstring = NULL;
     418             :             else
     419           0 :                 pstring = pg_client_to_server(abuf.data, argsize);
     420             : 
     421           0 :             fcinfo->args[i].value = OidInputFunctionCall(typinput, pstring,
     422             :                                                          typioparam, -1);
     423             :             /* Free result of encoding conversion, if any */
     424           0 :             if (pstring && pstring != abuf.data)
     425           0 :                 pfree(pstring);
     426             :         }
     427        3962 :         else if (aformat == 1)
     428             :         {
     429             :             Oid         typreceive;
     430             :             Oid         typioparam;
     431             :             StringInfo  bufptr;
     432             : 
     433             :             /* Call the argument type's binary input converter */
     434        3962 :             getTypeBinaryInputInfo(fip->argtypes[i], &typreceive, &typioparam);
     435             : 
     436        3962 :             if (argsize == -1)
     437           0 :                 bufptr = NULL;
     438             :             else
     439        3962 :                 bufptr = &abuf;
     440             : 
     441        3962 :             fcinfo->args[i].value = OidReceiveFunctionCall(typreceive, bufptr,
     442             :                                                            typioparam, -1);
     443             : 
     444             :             /* Trouble if it didn't eat the whole buffer */
     445        3962 :             if (argsize != -1 && abuf.cursor != abuf.len)
     446           0 :                 ereport(ERROR,
     447             :                         (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
     448             :                          errmsg("incorrect binary data format in function argument %d",
     449             :                                 i + 1)));
     450             :         }
     451             :         else
     452           0 :             ereport(ERROR,
     453             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     454             :                      errmsg("unsupported format code: %d", aformat)));
     455             :     }
     456             : 
     457             :     /* Return result format code */
     458        2084 :     return (int16) pq_getmsgint(msgBuf, 2);
     459             : }

Generated by: LCOV version 1.14