All functions are recursive, really (it just means they call each other). So-called "recursive functions" are just ones that directly or indirectly call themselves. Properly used, they're quite harmless, but a lack of care can see the computer getting caught up in the Catch-22 situation heralded by a "stack overflow".
When a computer (in this case, PHP) is running a program and comes to a point where a function is called, it has to save all the data being used by the program it's in at that moment, and pushes it onto a stack. Then it can start in on the called function. When that function finishes, PHP takes the data off the top of the stack, and is able to pick up again where it had left off.
A simple example:
function bar()
{
print('witless');
}
function foo()
{
$stuff='whatever';
bar();
print($stuff);
}
$barry='leftover';
foo();
PHP starts by setting $barry to 'leftover'. Then it's told to call foo(). PHP pushes $barry on to the stack, thenb starts foo(). foo() tells it to set $stuff to 'whatever'.
Then PHP is told to call bar(), so it has to push $stuff on to the stack as well.
Then bar() is run, which tells PHP to call print(). So that's another push on to the stack (no data this time, but it still needs to keep track of where it is in the program so that it can go back there afterward.)
When print() is finished, PHP "pops the stack" and finds out that it is to pick up where it left off in bar(). Nothing more to do there, so it pops again. This time, it finds itself back in foo() $stuff waiting for it, and another call to print(). So, push again, call print() again (passing the value of $stuff to it), and pop again back into foo(). foo() is finished now, so it can pop again, and now it's back at the top level again, with $barry='leftover'.
This stack can get quite large, with functions calling functions calling functions.... all so that the computer can keep track of where it is in each of the functions that haven't been finished yet. Stack Overflow is when this stack becomes too large for the computer to cope anymore, and is usually because some bug has meant that lots and lots of functions were getting started but none were being finished.
As crimaniak implied, this is usually because of a function that calls itself in some way and the computer gets stuck in a Catch-22 sort of situation. "To do that I have to do this, to do this I have to do that, to do that I have to do this, ...." with no end in sight. So it's there desparately calling functions that call functions that call the same functions again, pushing notes to itself onto the stack all the while, until the stack just falls over.
I can't tell you how to correct it because I haven't seen enough of your code. But look for functions that call themselves (or call functions that call them back; and longer loops are of course possile), and try to tell whether such loops ever end.
