#include "postgres.h"
#include <limits.h>
#include <sys/resource.h>
#include "miscadmin.h"
#include "utils/guc_hooks.h"

Include dependency graph for stack_depth.c:

Functions
pg_stack_base_t	set_stack_base (void)

void	restore_stack_base (pg_stack_base_t base)

void	check_stack_depth (void)

bool	stack_is_too_deep (void)

bool	check_max_stack_depth (int newval, void *extra, GucSource source)

void	assign_max_stack_depth (int newval, void *extra)

ssize_t	get_stack_depth_rlimit (void)

Variables
int	max_stack_depth = 100

static ssize_t	max_stack_depth_bytes = 100 * (ssize_t) 1024

static char *	stack_base_ptr = NULL

Function Documentation

◆ assign_max_stack_depth()

void assign_max_stack_depth	(	int	newval,
		void *	extra
	)

Definition at line 175 of file stack_depth.c.

{
    ssize_t     newval_bytes = newval * (ssize_t) 1024;
 
    max_stack_depth_bytes = newval_bytes;
}

References fb(), max_stack_depth_bytes, and newval.

◆ check_max_stack_depth()

bool check_max_stack_depth	(	int *	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 158 of file stack_depth.c.

{
    ssize_t     newval_bytes = *newval * (ssize_t) 1024;
    ssize_t     stack_rlimit = get_stack_depth_rlimit();
 
    if (stack_rlimit > 0 && newval_bytes > stack_rlimit - STACK_DEPTH_SLOP)
    {
        GUC_check_errdetail("\"max_stack_depth\" must not exceed %zdkB.",
                            (stack_rlimit - STACK_DEPTH_SLOP) / 1024);
        GUC_check_errhint("Increase the platform's stack depth limit via \"ulimit -s\" or local equivalent.");
        return false;
    }
    return true;
}

References fb(), get_stack_depth_rlimit(), GUC_check_errdetail, GUC_check_errhint, newval, and STACK_DEPTH_SLOP.

◆ check_stack_depth()

void check_stack_depth ( void )

Definition at line 96 of file stack_depth.c.

{
    if (stack_is_too_deep())
    {
        ereport(ERROR,
                (errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
                 errmsg("stack depth limit exceeded"),
                 errhint("Increase the configuration parameter \"max_stack_depth\" (currently %dkB), "
                         "after ensuring the platform's stack depth limit is adequate.",
                         max_stack_depth)));
    }
}

References ereport, errcode(), errhint(), errmsg, ERROR, fb(), max_stack_depth, and stack_is_too_deep().

Referenced by _jumbleNode(), AlterTypeRecurse(), apply_scanjoin_target_to_paths(), ATAddCheckNNConstraint(), ATExecAddColumn(), ATExecAlterCheckConstrEnforceability(), ATExecAlterConstrDeferrability(), ATExecAlterFKConstrEnforceability(), ATExecDropColumn(), ATExecSetNotNull(), CheckAttributeType(), checkCond(), clean_NOT_intree(), clean_stopword_intree(), cntsize(), contains_required_value(), convertJsonbValue(), copyObjectImpl(), Cover(), create_plan_recurse(), datum_to_json_internal(), datum_to_jsonb_internal(), dofindsubquery(), dropconstraint_internal(), emit_jsp_gin_entries(), equal(), eval_const_expressions_mutator(), EventTriggerInvoke(), ExecEndNode(), ExecEvalSubPlan(), ExecInitExprRec(), ExecInitNode(), ExecMakeFunctionResultSet(), ExecProcNodeFirst(), ExecShutdownNode_walker(), execute(), executeAnyItem(), executeBoolItem(), executeItemOptUnwrapTarget(), expand_partitioned_rtentry(), expr_is_nonnullable(), expression_tree_mutator_impl(), expression_tree_walker_impl(), extract_jsp_bool_expr(), fillQT(), find_composite_type_dependencies(), find_matching_subplans_recurse(), findDependentObjects(), findoprnd(), findoprnd(), findoprnd_recurse(), flatten_grouping_sets(), flattenJsonPathParseItem(), FreePageManagerDumpBtree(), freetree(), generate_partition_qual(), generate_partitionwise_join_paths(), generate_queries_for_path_pattern_recurse(), generate_setop_from_pathqueries(), get_graph_label_expr(), get_query_def(), get_rels_with_domain(), get_rule_expr(), get_setop_query(), get_steps_using_prefix_recurse(), gistSplit(), hash_range(), hash_range_extended(), hash_record(), hash_record_extended(), hk_depth_search(), infix(), infix(), infix(), inline_function_in_from(), int_query_opr_selec(), is_simple_union_all_recurse(), json_check_mutability(), JsonbDeepContains(), lseg_inside_poly(), ltree_execute(), makepol(), makepol(), makepol(), maketree(), MatchText(), MultiExecProcNode(), outNode(), p_ishost(), p_isURLPath(), parse_array(), parse_object(), parseNodeString(), plainnode(), planstate_tree_walker_impl(), plperl_hash_from_tuple(), plperl_sv_to_datum(), PLy_input_setup_func(), PLy_output_setup_func(), populate_array_dim_jsonb(), populate_record_field(), printJsonPathItem(), pull_up_sublinks_jointree_recurse(), pull_up_subqueries_recurse(), QT2QTN(), QTNBinary(), QTNClearFlags(), QTNCopy(), QTNFree(), QTNodeCompare(), QTNSort(), QTNTernary(), QueueFKConstraintValidation(), range_cmp(), range_in(), range_out(), range_recv(), range_send(), raw_expression_tree_walker_impl(), record_cmp(), record_eq(), record_in(), record_out(), record_recv(), record_send(), recurse_set_operations(), regex_selectivity_sub(), relation_is_updatable(), resolve_special_varno(), set_append_rel_size(), setPath(), split_array(), SplitToVariants(), standard_ProcessUtility(), transformExprRecurse(), transformFromClauseItem(), transformLabelExpr(), transformSetOperationTree(), traverse_lacons(), try_partitionwise_join(), TS_execute_locations_recurse(), TS_execute_recurse(), TS_phrase_execute(), tsquery_opr_selec(), and tsquery_requires_match().

◆ get_stack_depth_rlimit()

ssize_t get_stack_depth_rlimit ( void )

Definition at line 192 of file stack_depth.c.

{
#if defined(HAVE_GETRLIMIT)
    static ssize_t val = 0;
 
    /* This won't change after process launch, so check just once */
    if (val == 0)
    {
        struct rlimit rlim;
 
        if (getrlimit(RLIMIT_STACK, &rlim) < 0)
            val = -1;
        else if (rlim.rlim_cur == RLIM_INFINITY)
            val = SSIZE_MAX;
        /* rlim_cur is probably of an unsigned type, so check for overflow */
        else if (rlim.rlim_cur >= SSIZE_MAX)
            val = SSIZE_MAX;
        else
            val = rlim.rlim_cur;
    }
    return val;
#else
    /* On Windows we set the backend stack size in src/backend/Makefile */
    return WIN32_STACK_RLIMIT;
#endif
}

References fb(), and val.

Referenced by check_max_stack_depth(), and InitializeGUCOptionsFromEnvironment().

◆ restore_stack_base()

void restore_stack_base ( pg_stack_base_t base )

Definition at line 78 of file stack_depth.c.

{
    stack_base_ptr = base;
}

References stack_base_ptr.

◆ set_stack_base()

pg_stack_base_t set_stack_base ( void )

Definition at line 44 of file stack_depth.c.

{
#ifndef HAVE__BUILTIN_FRAME_ADDRESS
    char        stack_base;
#endif
    pg_stack_base_t old;
 
    old = stack_base_ptr;
 
    /*
     * Set up reference point for stack depth checking.  On recent gcc we use
     * __builtin_frame_address() to avoid a warning about storing a local
     * variable's address in a long-lived variable.  This is also important
     * with address sanitizer, see comment in stack_is_too_deep().
     */
#ifdef HAVE__BUILTIN_FRAME_ADDRESS
    stack_base_ptr = __builtin_frame_address(0);
#else
    stack_base_ptr = &stack_base;
#endif
 
    return old;
}

References fb(), and stack_base_ptr.

Referenced by main().

◆ stack_is_too_deep()

bool stack_is_too_deep ( void )

Definition at line 110 of file stack_depth.c.

{
#ifndef HAVE__BUILTIN_FRAME_ADDRESS
    char        stack_top_loc;
#endif
    ssize_t     stack_depth;
    char       *stack_address;
 
    /*
     * With address sanitizer's stack-use-after-return check, stack variables
     * are moved to heap allocations, to allow to detect references to the
     * memory at a later time. That would break our stack-depth check. Luckily
     * __builtin_frame_address() works correctly, even under asan.
     */
#ifndef HAVE__BUILTIN_FRAME_ADDRESS
    stack_address = &stack_top_loc;
#else
    stack_address = (char *) __builtin_frame_address(0);
#endif
 
    /*
     * Compute distance from reference point to my stack frame.
     */
    stack_depth = (ssize_t) (stack_base_ptr - stack_address);
 
    /*
     * Take abs value, since stacks grow up on some machines, down on others
     */
    if (stack_depth < 0)
        stack_depth = -stack_depth;
 
    /*
     * Trouble?
     *
     * The test on stack_base_ptr prevents us from erroring out if called
     * before that's been set.  Logically it should be done first, but putting
     * it last avoids wasting cycles during normal cases.
     */
    if (stack_depth > max_stack_depth_bytes &&
        stack_base_ptr != NULL)
        return true;
 
    return false;
}