Patchwork [U-Boot,v3,3/5] Allow U-Boot scripts to be placed in a .env file

login
register
mail settings
Submitter Simon Glass
Date Oct. 26, 2013, 5:01 a.m.
Message ID <1382763695-2849-4-git-send-email-sjg@chromium.org>
Download mbox | patch
Permalink /patch/286252/
State New
Delegated to: Tom Rini
Headers show

Comments

Simon Glass - Oct. 26, 2013, 5:01 a.m.
At present U-Boot environment variables, and thus scripts, are defined
by CONFIG_EXTRA_ENV_SETTINGS. It is painful to add large amounts of text
to this file and dealing with quoting and newlines is harder than it
should be. It would be better if we could just type the script into a
text file and have it included by U-Boot.

Add a feature that brings in a .env file associated with the board
config, if present. To use it, create a file in a board/<vendor>/env
directory called <board>.env (or common.env if you want the same
environment for all boards).

The environment variables should be of the form "var=value". Values can
extend to multiple lines. See the README under 'Environment Variables:'
for more information and an example.

Comments are not permitted in the environment with this commit.

Signed-off-by: Simon Glass <sjg@chromium.org>
---
Changes in v3:
- Add more detail in the README about the format of .env files
- Adjust Makefile to generate the .inc and .h files in separate fules
- Correctly terminate environment files with \n
- Improve the comment about " in the awk script

Changes in v2:
- Add dependency rule so that the environment is rebuilt when it changes
- Add information and updated example script to README
- Move .env file from include/configs to board/
- Use awk script to process environment since it is much easier on the brain

 Makefile                     | 35 +++++++++++++++++++++++++++++++-
 README                       | 38 +++++++++++++++++++++++++++++++++++
 common/env_embedded.c        |  1 +
 config.mk                    |  2 ++
 include/env_default.h        |  2 ++
 mkconfig                     |  7 +++++++
 tools/scripts/env2string.awk | 48 ++++++++++++++++++++++++++++++++++++++++++++
 7 files changed, 132 insertions(+), 1 deletion(-)
 create mode 100644 tools/scripts/env2string.awk
Wolfgang Denk - Oct. 26, 2013, 8:26 p.m.
Dear Simon,

In message <1382763695-2849-4-git-send-email-sjg@chromium.org> you wrote:
>
> +For example, for snapper9260 you would create a text file called
> +board/bluewater/env/snapper9260.env containing the environment text.
> +
> +>>>
> +bootcmd=
> +	if [ -z ${tftpserverip} ]; then
> +		echo "Use 'setenv tftpserverip a.b.c.d' to set IP address."
> +	fi
> +
> +	usb start; setenv autoload n; bootp;
> +	tftpboot ${tftpserverip}:
> +	bootm
> +failed=
> +	echo boot failed - please check your image
> +<<<
> +
> +The resulting environment can be exported and importing using the
> +'env export/import -t' commands.

I think this statement is misleading.  It reads as if thois text coul
actually be imported using "env import -t", which is not correct.  And
the result of an "env export -t" of equivalent command settings will
look pretty much different, too.

I can see why you like such a "beautified" text format, but I don;t
think you are doing anybody a favour here.  Can we not rather use
_exactly_ the same text format as U-Boot uses with it's import /
export commands?

This would make it _much_ easier to experiment on a system and modify
the environment until it fits all the requirements and passes all
tests, and then export it as a text file and use this directly
(without editing) for the input needed here?

...

> --- /dev/null
> +++ b/tools/scripts/env2string.awk
> @@ -0,0 +1,48 @@
> +#
> +# (C) Copyright 2013 Google, Inc
> +#
> +# SPDX-License-Identifier:	GPL-2.0+
> +#
> +# Sed script to parse a text file containing an environment and convert it
> +# to a C string which can be compiled into U-Boot.

That doesn't look like sed to me, looks more like awk :-)

> +	# Is this the start of a new environment variable?
> +	if (match($0, "^([^ =][^ =]*)=(.*)", arr)) {

I think this is a bit naive...

Example (using notation as exported by U-Boot using "env export -t"):

	foo=setenv xxx\
	one=1;setenv yyy\
	two=2;setenv zzz\
	three=3

> +	# Print out all the variables
> +	for (var in vars) {
> +		print var "=" vars[var] "\\0";
> +	}

I think it should not be difficult to find examples that would result
incorrect output.

I guess this needs more work - but then - why define a new format at
all?  Why not use what U-Boot uses itself?

Best regards,

Wolfgang Denk
Otavio Salvador - Oct. 28, 2013, 1:34 p.m.
Hello,

On Sat, Oct 26, 2013 at 3:01 AM, Simon Glass <sjg@chromium.org> wrote:
> At present U-Boot environment variables, and thus scripts, are defined
> by CONFIG_EXTRA_ENV_SETTINGS. It is painful to add large amounts of text
> to this file and dealing with quoting and newlines is harder than it
> should be. It would be better if we could just type the script into a
> text file and have it included by U-Boot.
>
> Add a feature that brings in a .env file associated with the board
> config, if present. To use it, create a file in a board/<vendor>/env
> directory called <board>.env (or common.env if you want the same
> environment for all boards).
>
> The environment variables should be of the form "var=value". Values can
> extend to multiple lines. See the README under 'Environment Variables:'
> for more information and an example.
>
> Comments are not permitted in the environment with this commit.
>
> Signed-off-by: Simon Glass <sjg@chromium.org>

I think people (or myself) are misunderstanding what this patch does.

My understand is:

 - it allow moving environment setting to a .env file
 - it needs to include the environment at /build/ time

This does improve a lot the current status (and I really appreciate
it); one missing thing (or I missed it completely) is a way to:

 - build u-boot (binary)
 - generate a binary version of the environment
 - glue both together in a way the new environment /replaces/ the
default environment originally written inside u-boot (binary)

Am I missing something?
Simon Glass - Oct. 28, 2013, 8:24 p.m.
Hi Wolfgang,

On Sat, Oct 26, 2013 at 2:26 PM, Wolfgang Denk <wd@denx.de> wrote:
> Dear Simon,
>
> In message <1382763695-2849-4-git-send-email-sjg@chromium.org> you wrote:
>>
>> +For example, for snapper9260 you would create a text file called
>> +board/bluewater/env/snapper9260.env containing the environment text.
>> +
>> +>>>
>> +bootcmd=
>> +     if [ -z ${tftpserverip} ]; then
>> +             echo "Use 'setenv tftpserverip a.b.c.d' to set IP address."
>> +     fi
>> +
>> +     usb start; setenv autoload n; bootp;
>> +     tftpboot ${tftpserverip}:
>> +     bootm
>> +failed=
>> +     echo boot failed - please check your image
>> +<<<
>> +
>> +The resulting environment can be exported and importing using the
>> +'env export/import -t' commands.
>
> I think this statement is misleading.  It reads as if thois text coul
> actually be imported using "env import -t", which is not correct.  And
> the result of an "env export -t" of equivalent command settings will
> look pretty much different, too.

The point here is that it is possible to export the default
environment that has been created at build time. Agreed this should be
worded better.

>
> I can see why you like such a "beautified" text format, but I don;t
> think you are doing anybody a favour here.  Can we not rather use
> _exactly_ the same text format as U-Boot uses with it's import /
> export commands?

That would be nice, but how to we handle newlines? Some scripts are
quite long. Do we need to put \ at the end of every line? That feels a
bit painful to me.

Also how do we handle #define? Without it I don't think this feature
is useful, since the existing build system often sticks CONFIG
variables into the environment.

>
> This would make it _much_ easier to experiment on a system and modify
> the environment until it fits all the requirements and passes all
> tests, and then export it as a text file and use this directly
> (without editing) for the input needed here?

I believe that is already possible - you should be able to take the
output of 'env export -t' and put it in the .env file. I have not
tried it though.

>
> ...
>
>> --- /dev/null
>> +++ b/tools/scripts/env2string.awk
>> @@ -0,0 +1,48 @@
>> +#
>> +# (C) Copyright 2013 Google, Inc
>> +#
>> +# SPDX-License-Identifier:   GPL-2.0+
>> +#
>> +# Sed script to parse a text file containing an environment and convert it
>> +# to a C string which can be compiled into U-Boot.
>
> That doesn't look like sed to me, looks more like awk :-)

Hmm, yes I gave up on sed after a while. Will fix.

>
>> +     # Is this the start of a new environment variable?
>> +     if (match($0, "^([^ =][^ =]*)=(.*)", arr)) {
>
> I think this is a bit naive...
>
> Example (using notation as exported by U-Boot using "env export -t"):
>
>         foo=setenv xxx\
>         one=1;setenv yyy\
>         two=2;setenv zzz\
>         three=3
>
>> +     # Print out all the variables
>> +     for (var in vars) {
>> +             print var "=" vars[var] "\\0";
>> +     }
>
> I think it should not be difficult to find examples that would result
> incorrect output.

I will take a look at this - here it is the \ at the end of line which
needs to be handled.

>
> I guess this needs more work - but then - why define a new format at
> all?  Why not use what U-Boot uses itself?

See above, would be good to resolve this issue before going any further.

Regards,
Simon
Simon Glass - Oct. 28, 2013, 8:26 p.m.
Hi Otavio,

On Mon, Oct 28, 2013 at 7:34 AM, Otavio Salvador
<otavio@ossystems.com.br> wrote:
> Hello,
>
> On Sat, Oct 26, 2013 at 3:01 AM, Simon Glass <sjg@chromium.org> wrote:
>> At present U-Boot environment variables, and thus scripts, are defined
>> by CONFIG_EXTRA_ENV_SETTINGS. It is painful to add large amounts of text
>> to this file and dealing with quoting and newlines is harder than it
>> should be. It would be better if we could just type the script into a
>> text file and have it included by U-Boot.
>>
>> Add a feature that brings in a .env file associated with the board
>> config, if present. To use it, create a file in a board/<vendor>/env
>> directory called <board>.env (or common.env if you want the same
>> environment for all boards).
>>
>> The environment variables should be of the form "var=value". Values can
>> extend to multiple lines. See the README under 'Environment Variables:'
>> for more information and an example.
>>
>> Comments are not permitted in the environment with this commit.
>>
>> Signed-off-by: Simon Glass <sjg@chromium.org>
>
> I think people (or myself) are misunderstanding what this patch does.

Possibly, I'm not sure.

>
> My understand is:
>
>  - it allow moving environment setting to a .env file
>  - it needs to include the environment at /build/ time

Yes

>
> This does improve a lot the current status (and I really appreciate
> it); one missing thing (or I missed it completely) is a way to:
>
>  - build u-boot (binary)
>  - generate a binary version of the environment
>  - glue both together in a way the new environment /replaces/ the
> default environment originally written inside u-boot (binary)
>
> Am I missing something?

This is something that Wolfgang would like to see (as would I), but I
think it is a separate feature. This feature is just trying to
simplify creation of the build-time default environment.

Regards,
Simon
Wolfgang Denk - Oct. 28, 2013, 9:16 p.m.
Dear Simon,

In message <CAPnjgZ0+35Zd6_o=G0=G-YL_mR-GiTW+MeYqK7BSxU_nVkvv1w@mail.gmail.com> you wrote:
> 
> > I can see why you like such a "beautified" text format, but I don;t
> > think you are doing anybody a favour here.  Can we not rather use
> > _exactly_ the same text format as U-Boot uses with it's import /
> > export commands?
> 
> That would be nice, but how to we handle newlines? Some scripts are
> quite long. Do we need to put \ at the end of every line? That feels a
> bit painful to me.

Agreed.  But that's what "env export -t" creates anyway (and I cannot
think of a much better presentation of multiline variable content if
you don't want to run in ambiguities).

> Also how do we handle #define? Without it I don't think this feature
> is useful, since the existing build system often sticks CONFIG
> variables into the environment.

I don't understand this question here.  I agree that we should be able
to run the file through the preprocessor such that it can resolve such
macro definitions.  But this should be independent of the actual text
format, or am I missing something?

> I believe that is already possible - you should be able to take the
> output of 'env export -t' and put it in the .env file. I have not
> tried it though.

Hm... I really think we should agree on a common format her e- one
that is easy to work with on both sides.

> > Example (using notation as exported by U-Boot using "env export -t"):
> >
> >         foo=setenv xxx\
> >         one=1;setenv yyy\
> >         two=2;setenv zzz\
> >         three=3
> >
> >> +     # Print out all the variables
> >> +     for (var in vars) {
> >> +             print var "=" vars[var] "\\0";
> >> +     }
> >
> > I think it should not be difficult to find examples that would result
> > incorrect output.
> 
> I will take a look at this - here it is the \ at the end of line which
> needs to be handled.

Well, I can't see how you avoid such ambiguities in your proposed
format.  You need a clear termination for the value of a variable.
If it is spread across multiple lines, you have to find a way to mark
continuation lines.  The "accepted standard" way to do so is by using
a backslash at the end of the line.  It appears you want to use
indentation instead - this prevents users from using a free text
format, and quickly becomes messy.  And it is incompatible to
(current) U-Boot code.

> > I guess this needs more work - but then - why define a new format at
> > all?  Why not use what U-Boot uses itself?
> 
> See above, would be good to resolve this issue before going any further.

"Above" I cannot see any explanation why you define a new format
except for the fact that the backslash as marker for continuation
lines is "painful".   I'm open on discussing a new format for text
representation (which then also should be used by "env print" and "env
export -t" ?).  But I'd like to see a description of that format
first (and not just a few examples I can guess from).

Best regards,

Wolfgang Denk
Simon Glass - Oct. 28, 2013, 10:22 p.m.
Hi Wolfgang,

On Mon, Oct 28, 2013 at 3:16 PM, Wolfgang Denk <wd@denx.de> wrote:
> Dear Simon,
>
> In message <CAPnjgZ0+35Zd6_o=G0=
G-YL_mR-GiTW+MeYqK7BSxU_nVkvv1w@mail.gmail.com> you wrote:
>>
>> > I can see why you like such a "beautified" text format, but I don;t
>> > think you are doing anybody a favour here.  Can we not rather use
>> > _exactly_ the same text format as U-Boot uses with it's import /
>> > export commands?
>>
>> That would be nice, but how to we handle newlines? Some scripts are
>> quite long. Do we need to put \ at the end of every line? That feels a
>> bit painful to me.
>
> Agreed.  But that's what "env export -t" creates anyway (and I cannot
> think of a much better presentation of multiline variable content if
> you don't want to run in ambiguities).

I believe the ambiguities are pretty rare. And people tend to indent
multi-line scripts anyway, right?

>
>> Also how do we handle #define? Without it I don't think this feature
>> is useful, since the existing build system often sticks CONFIG
>> variables into the environment.
>
> I don't understand this question here.  I agree that we should be able
> to run the file through the preprocessor such that it can resolve such
> macro definitions.  But this should be independent of the actual text
> format, or am I missing something?

Yes we can, agreed. I was thinking you would not want the preprocessor
since 'env export -t' doesn't understand it.

>
>> I believe that is already possible - you should be able to take the
>> output of 'env export -t' and put it in the .env file. I have not
>> tried it though.
>
> Hm... I really think we should agree on a common format her e- one
> that is easy to work with on both sides.

Agreed.

>
>> > Example (using notation as exported by U-Boot using "env export -t"):
>> >
>> >         foo=setenv xxx\
>> >         one=1;setenv yyy\
>> >         two=2;setenv zzz\
>> >         three=3
>> >
>> >> +     # Print out all the variables
>> >> +     for (var in vars) {
>> >> +             print var "=" vars[var] "\\0";
>> >> +     }
>> >
>> > I think it should not be difficult to find examples that would result
>> > incorrect output.
>>
>> I will take a look at this - here it is the \ at the end of line which
>> needs to be handled.
>
> Well, I can't see how you avoid such ambiguities in your proposed
> format.  You need a clear termination for the value of a variable.
> If it is spread across multiple lines, you have to find a way to mark
> continuation lines.  The "accepted standard" way to do so is by using
> a backslash at the end of the line.  It appears you want to use
> indentation instead - this prevents users from using a free text
> format, and quickly becomes messy.  And it is incompatible to
> (current) U-Boot code.

Indentation is pretty normal in code, so I don't feel embarrassed about
asking for it. I think the primary problem with my feature is that it is
different from 'env export -t', and thus potentially introduces another
format. My argument against that interpretation is that I am in fact
replacing a C header file definition with a text file, so perhaps I'm not
really increasing the number of formats?

>
>> > I guess this needs more work - but then - why define a new format at
>> > all?  Why not use what U-Boot uses itself?
>>
>> See above, would be good to resolve this issue before going any further.
>
> "Above" I cannot see any explanation why you define a new format
> except for the fact that the backslash as marker for continuation
> lines is "painful".   I'm open on discussing a new format for text
> representation (which then also should be used by "env print" and "env
> export -t" ?).  But I'd like to see a description of that format
> first (and not just a few examples I can guess from).

From my commit message:

At present U-Boot environment variables, and thus scripts, are defined
> by CONFIG_EXTRA_ENV_SETTINGS. It is painful to add large amounts of text
> to this file and dealing with quoting and newlines is harder than it
> should be. It would be better if we could just type the script into a
> text file and have it included by U-Boot.


Well yes I could adjust 'env export -t' to use the same format - is that a
good idea, or not? I can see down-sides. We can of course convert existing
files brought in by 'env import -t' (by making the import flexible) but I
worry that there might be external tools that users have which expect the
format to be a certain way.

I agree creating a new format is not ideal - it's just that the existing C
header format is so painful...

Regards,
Simon
Wolfgang Denk - Oct. 28, 2013, 11:52 p.m.
Dear Simon,

In message <CAPnjgZ3tGwRK2ytm59EKUmAiPD5kAq39Mu9BityL0Y6d0H2C1w@mail.gmail.com> you wrote:
>
> > Agreed.  But that's what "env export -t" creates anyway (and I cannot
> > think of a much better presentation of multiline variable content if
> > you don't want to run in ambiguities).
> 
> I believe the ambiguities are pretty rare. And people tend to indent
> multi-line scripts anyway, right?

Do they? In the current include/config/*.h files, there is basically
zero structuring of the environment as nobody has been using
multi-line variables yet.   Yes, there is indentation in the header
files, but this is not visible at all in the environment variables.

> > I don't understand this question here.  I agree that we should be able
> > to run the file through the preprocessor such that it can resolve such
> > macro definitions.  But this should be independent of the actual text
> > format, or am I missing something?
> 
> Yes we can, agreed. I was thinking you would not want the preprocessor
> since 'env export -t' doesn't understand it.

Well, of course it deosn't, as it cannot invert the operation of the C
preprocessor...  But we can still use the prepro to create output that
is digestable to "env import -t", right?

> > Well, I can't see how you avoid such ambiguities in your proposed
> > format.  You need a clear termination for the value of a variable.
> > If it is spread across multiple lines, you have to find a way to mark
> > continuation lines.  The "accepted standard" way to do so is by using
> > a backslash at the end of the line.  It appears you want to use
> > indentation instead - this prevents users from using a free text
> > format, and quickly becomes messy.  And it is incompatible to
> > (current) U-Boot code.
> 
> Indentation is pretty normal in code, so I don't feel embarrassed about
> asking for it. I think the primary problem with my feature is that it is
> different from 'env export -t', and thus potentially introduces another
> format. My argument against that interpretation is that I am in fact
> replacing a C header file definition with a text file, so perhaps I'm not
> really increasing the number of formats?

Well, I'm afraid you have not yet formally defined the syntax of your
format, so I may just misunderstand what you mean.

> Well yes I could adjust 'env export -t' to use the same format - is that a
> good idea, or not? I can see down-sides. We can of course convert existing
> files brought in by 'env import -t' (by making the import flexible) but I
> worry that there might be external tools that users have which expect the
> format to be a certain way.

Are there any such tools?  Anybodyu who is using such please speak up
now and here! ;-)

> I agree creating a new format is not ideal - it's just that the existing C
> header format is so painful...

Yes, I agree on that, and I'm more than willing to get rid of it.  But
it has to be something that is actually working, and that is easy to
work with.

> --485b3970d160c06fb304e9d48797
> Content-Type: text/html; charset=ISO-8859-1
> Content-Transfer-Encoding: quoted-printable
> 
> <div dir=3D"ltr">Hi Wolfgang,<br><br>On Mon, Oct 28, 2013 at 3:16 PM, Wolfg=
> ang Denk &lt;<a href=3D"mailto:wd@denx.de">wd@denx.de</a>&gt; wrote:<br>&gt=
...


Argh... can you please turn this off?

Best regards,

Wolfgang Denk

Patch

diff --git a/Makefile b/Makefile
index 2d18d27..a9b4b9e 100644
--- a/Makefile
+++ b/Makefile
@@ -708,7 +708,7 @@  $(obj)include/autoconf.mk.dep: $(obj)include/config.h include/common.h
 	$(CC) -x c -DDO_DEPS_ONLY -M $(CFLAGS) $(CPPFLAGS) \
 		-MQ $(obj)include/autoconf.mk include/common.h > $@
 
-$(obj)include/autoconf.mk: $(obj)include/config.h
+$(obj)include/generated/autoconf.mk.base: $(obj)include/config.h
 	@$(XECHO) Generating $@ ; \
 	set -e ; \
 	: Extract the config macros ; \
@@ -734,6 +734,39 @@  $(obj)include/spl-autoconf.mk: $(obj)include/config.h
 	sed -n -f tools/scripts/define2mk.sed > $@.tmp && \
 	mv $@.tmp $@
 
+# We expect '<board>.env' but failing that will use 'common.env'
+ENV_HEADER := $(obj)include/generated/environment.h
+ENV_DIR := $(if $(VENDOR),$(VENDOR)/env,$(BOARD)/env)
+ENV_FILE_BOARD := $(src)board/${ENV_DIR}/$(BOARD).env
+ENV_FILE_COMMON := $(src)board/${ENV_DIR}/common.env
+ENV_FILE := $(if $(wildcard $(ENV_FILE_BOARD)),$(ENV_FILE_BOARD),$(ENV_FILE_COMMON))
+
+# Regenerate the environment if it changes
+$(obj)include/generated/environment.in: $(obj)include/generated/autoconf.mk.base \
+		$(wildcard $(ENV_FILE))
+	if [ -f "$(ENV_FILE)" ]; then \
+		cat $(ENV_FILE) >$@ ; \
+	else \
+		echo -n >$@ ; \
+	fi
+
+$(obj)include/generated/environment.inc: $(obj)include/generated/environment.in
+	@$(XECHO) Generating $@ ; \
+	set -e ; \
+	: Process the environment file ; \
+	echo -n "CONFIG_EXTRA_ENV_TEXT=" >$@ ; \
+	awk -f tools/scripts/env2string.awk $< >>$@
+
+$(ENV_HEADER): $(obj)include/generated/environment.in
+	@$(XECHO) Generating $@ ; \
+	set -e ; \
+	: Process the environment file ; \
+	echo -n "#define CONFIG_EXTRA_ENV_TEXT " >$@ ; \
+	awk -f tools/scripts/env2string.awk $< >>$@
+
+$(obj)include/autoconf.mk: $(obj)include/generated/environment.inc $(ENV_HEADER)
+	cat $(obj)include/generated/autoconf.mk.base $< >$@
+
 $(obj)include/generated/generic-asm-offsets.h:	$(obj)include/autoconf.mk.dep \
 	$(obj)include/spl-autoconf.mk \
 	$(obj)include/tpl-autoconf.mk \
diff --git a/README b/README
index f0eedbb..3146a2d 100644
--- a/README
+++ b/README
@@ -4556,6 +4556,44 @@  environment. As long as you don't save the environment you are
 working with an in-memory copy. In case the Flash area containing the
 environment is erased by accident, a default environment is provided.
 
+The default environment is created in include/env_default.h, and can be
+augmented by various CONFIG defines. See that file for details. In
+particular you can define CONFIG_EXTRA_ENV_SETTINGS in your board file
+to add environment variables (see 'CONFIG_EXTRA_ENV_SETTINGS' above
+for details).
+
+It is also possible to create an environment file with the name
+board/<vendor>/env/<board>.env for your board. If that file is not present
+then U-Boot will look for board/<vendor>/env/common.env so that you can
+have a common environment for all vendor boards.
+
+This is a plain text file where you can type your environment variables in
+the form 'var=value'. Blank lines and multi-line variables are supported.
+The conversion script looks for a line that starts with a letter or number
+and has an equals sign immediately afterwards. Spaces before the = are not
+permitted. It is a good idea to indent your scripts so that only the 'var='
+appears at the start of a line.
+
+For example, for snapper9260 you would create a text file called
+board/bluewater/env/snapper9260.env containing the environment text.
+
+>>>
+bootcmd=
+	if [ -z ${tftpserverip} ]; then
+		echo "Use 'setenv tftpserverip a.b.c.d' to set IP address."
+	fi
+
+	usb start; setenv autoload n; bootp;
+	tftpboot ${tftpserverip}:
+	bootm
+failed=
+	echo boot failed - please check your image
+<<<
+
+The resulting environment can be exported and importing using the
+'env export/import -t' commands.
+
+
 Some configuration options can be set using Environment Variables.
 
 List of environment variables (most likely not complete):
diff --git a/common/env_embedded.c b/common/env_embedded.c
index 1c4f915..1d7fe2a 100644
--- a/common/env_embedded.c
+++ b/common/env_embedded.c
@@ -74,6 +74,7 @@ 
 #endif
 
 #define DEFAULT_ENV_INSTANCE_EMBEDDED
+#include <config.h>
 #include <env_default.h>
 
 #ifdef CONFIG_ENV_ADDR_REDUND
diff --git a/config.mk b/config.mk
index 91a8f24..a9f3317 100644
--- a/config.mk
+++ b/config.mk
@@ -190,8 +190,10 @@  sinclude $(TOPDIR)/$(CPUDIR)/$(SOC)/config.mk	# include  SoC	specific rules
 endif
 ifdef	VENDOR
 BOARDDIR = $(VENDOR)/$(BOARD)
+ENVDIR=${vendor}/env
 else
 BOARDDIR = $(BOARD)
+ENVDIR=${board}/env
 endif
 ifdef	BOARD
 sinclude $(TOPDIR)/board/$(BOARDDIR)/config.mk	# include board specific rules
diff --git a/include/env_default.h b/include/env_default.h
index 90431be..b88b1e4 100644
--- a/include/env_default.h
+++ b/include/env_default.h
@@ -121,6 +121,8 @@  const uchar default_environment[] = {
 #ifdef	CONFIG_EXTRA_ENV_SETTINGS
 	CONFIG_EXTRA_ENV_SETTINGS
 #endif
+	/* This is created in the Makefile */
+	CONFIG_EXTRA_ENV_TEXT
 	"\0"
 #ifdef DEFAULT_ENV_INSTANCE_EMBEDDED
 	}
diff --git a/mkconfig b/mkconfig
index 1d06c8e..8240431 100755
--- a/mkconfig
+++ b/mkconfig
@@ -144,8 +144,10 @@  fi
 # Assign board directory to BOARDIR variable
 if [ -z "${vendor}" ] ; then
     BOARDDIR=${board}
+    ENVDIR=${board}/env
 else
     BOARDDIR=${vendor}/${board}
+    ENVDIR=${vendor}/env
 fi
 
 #
@@ -174,10 +176,15 @@  echo "#define CONFIG_SYS_BOARD \"${board}\"" >> config.h
 
 cat << EOF >> config.h
 #define CONFIG_BOARDDIR board/$BOARDDIR
+#define CONFIG_ENVDIR board/$ENVDIR
 #include <config_cmd_defaults.h>
 #include <config_defaults.h>
 #include <configs/${CONFIG_NAME}.h>
 #include <asm/config.h>
+#if !defined(DO_DEPS_ONLY) && !defined(D__UBOOT_CONFIG__) && \
+	!defined(__ASSEMBLY__)
+#include <generated/environment.h>
+#endif
 #include <config_fallbacks.h>
 #include <config_uncmd_spl.h>
 EOF
diff --git a/tools/scripts/env2string.awk b/tools/scripts/env2string.awk
new file mode 100644
index 0000000..2a86494
--- /dev/null
+++ b/tools/scripts/env2string.awk
@@ -0,0 +1,48 @@ 
+#
+# (C) Copyright 2013 Google, Inc
+#
+# SPDX-License-Identifier:	GPL-2.0+
+#
+# Sed script to parse a text file containing an environment and convert it
+# to a C string which can be compiled into U-Boot.
+#
+
+# We output a double quote before starting, and again when we finish so that
+# all output is quoted.
+BEGIN {
+	# env holds the env variable we are currently processing
+	env = "";
+	ORS = ""
+	print "\""
+}
+
+{
+	# Quote quotes
+	gsub("\"", "\\\"")
+
+	# Is this the start of a new environment variable?
+	if (match($0, "^([^ =][^ =]*)=(.*)", arr)) {
+		if (length(env) != 0) {
+			# Record the value of the variable now completed
+			vars[var] = env
+		}
+		var = arr[1]
+		env = arr[2]
+	} else {
+		# Change newline to \n
+		env = env "\\n" $0;
+	}
+}
+
+END {
+	# Record the value of the variable now completed
+	if (length(env) != 0) {
+		vars[var] = env
+	}
+
+	# Print out all the variables
+	for (var in vars) {
+		print var "=" vars[var] "\\0";
+	}
+	print "\"\n"
+}