autoload: Add subshell scoping to loop detection (re: a410bc4)

@perette reports:
> Korn Shell erroneously reports there is an autoload loop when:
>
> * I have a main program that autoloads a helper function. That
>   function is only called during shell captures.
> * That function autoloads a third function.
>
> The first invocation doing a shell capture succeeds. Successive
> ones report "autoload loop" in the helper function.

Analysis: In the referenced commit, I failed to account for loading
functions in virtual (non-forking) subshells, such as command
substitutions ('shell captures'), without them being loaded in the
parent shell envioronment. The loop detection state leaks out of
those subshells, whereas the functions themselves do not.

src/cmd/ksh93/sh/path.c,
src/cmd/ksh93/sh/subshell.c,
src/cmd/ksh93/include/defs.h,
src/cmd/ksh93/include/shell.h:
- Implements subshell scoping for the Cdt tree that keeps track of
  the names of functions that are currently being autoloaded. This
  works analogously to the subshell scoping for the variable,
  function, and hash table trees, but is much simpler, because the
  autoload loop detection tree only has nodes without values. The
  sh_subloopdetecttree function is used to create a new subshell
  tree. The sfaldt field of the subshell data is used to save it
  and clean it up when the subshell exits. In funload(), when
  adding a note, we now also need to pass the NV_NOSCOPE flag to
  nv_search to add it to the subshell tree (if any) and not the
  parent tree.
- Fix another problem that I discovered while fixing this. When the
  script invoked by autoload contains an error that causes the
  shell context to exit, such as an error in a special builtin, the
  shell longjmps away from funload(), the state never gets
  restored, and there is a memory leak as free() is not called. Fix
  this by adding a sh_pushcontext/sigsetjmp procedure of its own so
  the shell longjmps back to the correct point in funload() to
  restore state correctly before continuing down the longjmp chain.

src/cmd/ksh93/data/msg.c,
src/cmd/ksh93/include/shell.h,
src/cmd/ksh93/sh/xec.c:
- Improve the error message given when an autoloadable function is
  not found, by including the name of the not-found function in it.
  This fix is by Perette Barella (thanks!).

Resolves: #971
Co-authored-by: Perette Barella <perette@barella.org>

Author: McDutchie

NEWS

@@ -2,6 +2,11 @@ This documents significant changes in the 1.0 branch of ksh 93u+m.
 For full details, see the git log at: https://github.com/ksh93/ksh/tree/1.0
 Uppercase BUG_* IDs are shell bug IDs as used by the Modernish shell library.
 
+2026-04-16:
+
+- Fixed breakage in autoload loop detection when first invoking an
+  autoloadable function on FPATH from within a subshell.
+
 2026-04-14:
 
 - Ksh is now capable of allocating memory within a 64-bit address space. This

src/cmd/ksh93/data/msg.c

@@ -77,6 +77,7 @@ const char e_logout[]		= "Use 'exit' to terminate this shell";
 const char e_exec[]		= "%s: cannot execute";
 const char e_pwd[]		= "cannot determine present working directory";
 const char e_found[]		= "%s: not found";
+const char e_autoloadnotfound[] = "autoload: %s: function not found";
 #ifdef ENAMETOOLONG
 const char e_toolong[]		= "%s: file name too long";
 #endif

src/cmd/ksh93/include/defs.h

@@ -129,6 +129,7 @@ extern void		sh_setmatch(const char*,ptrdiff_t,ssize_t,ssize_t[],int);
 extern void		sh_scope(struct argnod*, int);
 extern Namval_t		*sh_scoped(Namval_t*);
 extern Dt_t		*sh_subtracktree(int);
+extern Dt_t		*sh_subloopdetecttree(int);
 extern Dt_t		*sh_subfuntree(int);
 extern void		sh_subjobcheck(pid_t);
 extern int		sh_subsavefd(int);

src/cmd/ksh93/include/shell.h

@@ -166,6 +166,7 @@ typedef union Shnode_u Shnode_t;
 
 /* error messages */
 extern const char	e_found[];
+extern const char	e_autoloadnotfound[];
 #ifdef ENAMETOOLONG
 extern const char	e_toolong[];
 #endif
@@ -314,7 +315,7 @@ struct Shell_s
 	char		intrap_exit_n;	/* set if 'exit n' within trap */
 	char		forked;
 	char		binscript;
-	char		funload;
+	char		funload;	/* set while autoloading a function via funload() */
 	char		used_pos;	/* used positional parameter */
 	char		universe;
 	char		winch;		/* set upon window size change or 'set -b' notification */
@@ -380,6 +381,7 @@ struct Shell_s
 	Dt_t		*prev_root;
 	Dt_t		*fpathdict;
 	Dt_t		*typedict;
+	Dt_t		*funload_loopdetect_tree; /* for function autoload loop detection */
 	char		ifstable[256];
 	Shopt_t		offoptions;	/* options that were explicitly disabled by the user on the command line */
 	Shopt_t		glob_options;

src/cmd/ksh93/sh/path.c

@@ -540,11 +540,14 @@ char *path_fullname(const char *name)
 static void funload(int fno, const char *name)
 {
 	char		*pname,*oldname=sh.st.filename, buff[IOBSIZE+1];
-	Namval_t	*np, *np_loopdetect;
-	static Dt_t	*loopdetect_tree;
+	Namval_t	*np_loopdetect;
+	Dt_t		*loopdetect_tree;
 	struct Ufunction *rp,*rpfirst;
 	int		savestates = sh_getstate(), savelineno = sh.inlineno;
 	char		oldload = sh.funload;
+	volatile char	*errorname = NULL;
+	volatile int	jmpval;
+	struct checkpt	checkpoint;
 	pname = path_fullname(stkptr(sh.stk,PATH_OFFSET));
 	if(sh.fpathdict && (rp = dtmatch(sh.fpathdict,pname)))
 	{
@@ -558,6 +561,7 @@ static void funload(int fno, const char *name)
 		}
 		do
 		{
+			Namval_t *np;
 			if((np = dtsearch(funtree,rp->np)) && is_afunction(np))
 			{
 				if(np->nvalue)
@@ -572,42 +576,55 @@ static void funload(int fno, const char *name)
 		free(pname);
 		return;
 	}
-	if(!loopdetect_tree)
-		loopdetect_tree = dtopen(&_Nvdisc,Dtoset);
-	else if(nv_search(pname,loopdetect_tree,0))
+	loopdetect_tree = sh_subloopdetecttree(1);
+	if(nv_search(pname,loopdetect_tree,0))
 	{
+		dtclear(loopdetect_tree);
 		errormsg(SH_DICT,ERROR_exit(ERROR_NOEXEC),"autoload loop: %s in %s",name,pname);
 		UNREACHABLE();
 	}
-	np_loopdetect = nv_search(pname,loopdetect_tree,NV_ADD);
+	np_loopdetect = nv_search(pname,loopdetect_tree,NV_ADD|NV_NOSCOPE);
 	sh_onstate(SH_NOALIAS);
 	sh.readscript = (char*)name;
 	sh.st.filename = pname;
 	sh.funload = 1;
 	sh.inlineno = 1;
 	error_info.line = 0;
-	sh_eval(sfnew(NULL,buff,IOBSIZE,fno,SFIO_READ),SH_FUNEVAL);
-	sh_close(fno);
-	sh.readscript = 0;
+	/* sh_eval may longjmp if the script throws an error; to restore
+	 * state, we must include this function in the longjmp chain */
+	sh_pushcontext(&checkpoint,1);
+	jmpval = sigsetjmp(checkpoint.buff,0);
+	if(!jmpval)
+	{
+		Namval_t *np;
+		/* run the function script */
+		sh_eval(sfnew(NULL,buff,IOBSIZE,fno,SFIO_READ),SH_FUNEVAL);
+		/* check if the expected function was loaded */
 #if SHOPT_NAMESPACE
-	if(sh.namespace)
-		np = sh_fsearch(name,0);
-	else
+		if(sh.namespace)
+			np = sh_fsearch(name,0);
+		else
 #endif /* SHOPT_NAMESPACE */
-		np = nv_search(name,sh.fun_tree,0);
-	if(!np || !np->nvalue)
-		pname = stkcopy(sh.stk,sh.st.filename);
-	else
-		pname = 0;
-	free(sh.st.filename);
+			np = nv_search(name,sh.fun_tree,0);
+		if(!np || !np->nvalue)
+			errorname = stkcopy(sh.stk,sh.st.filename);
+	}
+	/* restore state */
+	sh_close(fno);
+	sh.readscript = 0;
+	free(pname);
 	sh.funload = oldload;
 	sh.inlineno = savelineno;
 	sh.st.filename = oldname;
 	sh_setstate(savestates);
 	nv_delete(np_loopdetect,loopdetect_tree,0);
-	if(pname)
+	/* continue the longjmp chain on error */
+	sh_popcontext(&checkpoint);
+	if(jmpval)
+		siglongjmp(*sh.jmplist,jmpval);
+	if(errorname)
 	{
-		errormsg(SH_DICT,ERROR_exit(ERROR_NOEXEC),e_funload,name,pname);
+		errormsg(SH_DICT,ERROR_exit(ERROR_NOEXEC),e_funload,name,errorname);
 		UNREACHABLE();
 	}
 }

src/cmd/ksh93/sh/subshell.c

@@ -57,6 +57,7 @@ static struct subshell
 	struct Link	*svar;	/* save shell variable table */
 	Dt_t		*sfun;	/* function scope for subshell */
 	Dt_t		*strack;/* tracked alias scope for subshell */
+	Dt_t		*sfaldt;/* subshell function autoload loop detection tree */
 	Pathcomp_t	*pathlist; /* for PATH variable */
 	Shopt_t		options;/* save shell options */
 	pid_t		subpid;	/* child process ID */
@@ -425,6 +426,27 @@ Dt_t *sh_subfuntree(int create)
 	return sh.fun_tree;
 }
 
+/*
+ * Return pointer to the function autoload loop detection tree.
+ * Create new one if in a subshell and one doesn't exist and 'create' is non-zero.
+ */
+Dt_t *sh_subloopdetecttree(int create)
+{
+	struct subshell *sp = subshell_data;
+	if(!sh.funload_loopdetect_tree)
+		sh.funload_loopdetect_tree = dtopen(&_Nvdisc,Dtoset);
+	if(create && sh.subshell && !sh.subshare)
+	{
+		if(sp && !sp->sfaldt)
+		{
+			sp->sfaldt = dtopen(&_Nvdisc,Dtoset);
+			dtview(sp->sfaldt, sh.funload_loopdetect_tree);
+			sh.funload_loopdetect_tree = sp->sfaldt;
+		}
+	}
+	return sh.funload_loopdetect_tree;
+}
+
 int sh_subsavefd(int fd)
 {
 	struct subshell *sp = subshell_data;
@@ -840,6 +862,12 @@ Sfio_t *sh_subshell(Shnode_t *t, volatile int flags, char comsub)
 			}
 			dtclose(sp->sfun);
 		}
+		/* Clean up subshell autoload loop detection tree. */
+		if(sp->sfaldt)
+		{
+			sh.funload_loopdetect_tree = dtview(sp->sfaldt,0);
+			dtclose(sp->sfaldt);
+		}
 		n = sh.st.trapmax-savst.trapmax;
 		sh_sigreset(1);
 		if(n>0)

src/cmd/ksh93/sh/xec.c

@@ -1270,7 +1270,7 @@ int sh_exec(const Shnode_t *t, int flags)
 							}
 							else
 							{
-								errormsg(SH_DICT,ERROR_exit(0),e_found,"function");
+								errormsg(SH_DICT,ERROR_exit(0),e_autoloadnotfound,com0);
 								sh.exitval = ERROR_NOENT;
 							}
 							goto setexit;

src/cmd/ksh93/tests/functions.sh

@@ -1574,5 +1574,47 @@ do	got=$(unset -f "$b"; PATH=/dev/null; "$b" --version 2>&1)
 		"(expected status 2 and ERE match of $(printf %q "$exp"), got status $e and $(printf %q "$got"))"
 done
 
+# ======
+# test autoloading a function from within a command substitutino
+# https://github.com/ksh93/ksh/issues/971
+
+print -r >test_program \
+'autoload my_function
+
+# If I called this function directly, all problems go away:
+# my_function
+
+# Without that, this first command substitution works:
+functions my_function third_function
+print "$(my_function)"
+
+# But when I do it a second time:
+functions my_function third_function
+print "$(my_function)"
+# ./test_program: line 4: autoload loop: my_function in /home/perette/bin/shfuncs/my_function'
+
+print -r >my_function \
+'autoload third_function
+function my_function {
+        third_function
+        print "my_function was called."
+}'
+
+print -r >third_function \
+'function third_function {
+        print "Third function got called."
+}'
+
+got=$(FPATH=$PWD; set +x; . ./test_program 2>&1)
+exp='typeset -fu my_function
+Third function got called.
+my_function was called.
+typeset -fu my_function
+Third function got called.
+my_function was called.'
+
+[[ $got == "$exp" ]] || err_exit "autoloading a function from a command substitution" \
+	"(expected $(printf %q "$exp"), got $(printf %q "$got"))"
+
 # ======
 exit $((Errors<125?Errors:125))