lkml.org 
[lkml]   [2015]   [Apr]   [22]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    SubjectRe: [PATCH v4 2/2] efi: an sysfs interface for user to update efi firmware
    From
    Date
    On Wed, 2015-04-22 at 09:27 -0400, Peter Jones wrote:
    > On Tue, Apr 21, 2015 at 06:58:58PM -0700, Andy Lutomirski wrote:
    > > On Tue, Apr 21, 2015 at 6:21 PM, James Bottomley
    > > <James.Bottomley@hansenpartnership.com> wrote:
    > > > Andy, just on the misc device idea, what about triggering the capsule
    > > > update from close()? In theory close returns an error code (not sure if
    > > > most tools actually check this, though). That means we can do the write
    > > > in chunks but pass it in atomically on the close and cat will work
    > > > (provided it checks the return code of close).
    > >
    > > I thought about this but IIRC cat doesn't check the return value from close.
    >
    > I checked this for the use case we'd talked about before - gnu cat
    > /does/ check the error code, but it's easy to miss how, because
    > coreutils code has some good ole' gnu-code complexity. It'll print the
    > strerror() representation, but it always exits with 1 as the error
    > code.
    >
    > Specifically the close on the output is handled by this:
    > ---------------
    > initialize_main (&argc, &argv);
    > set_program_name (argv[0]);
    > setlocale (LC_ALL, "");
    > bindtextdomain (PACKAGE, LOCALEDIR);
    > textdomain (PACKAGE);
    >
    > /* Arrange to close stdout if we exit via the
    > case_GETOPT_HELP_CHAR or case_GETOPT_VERSION_CHAR code.
    > Normally STDOUT_FILENO is used rather than stdout, so
    > close_stdout does nothing. */
    > atexit (close_stdout);
    >
    > /* Parse command line options. */
    >
    > while ((c = getopt_long (argc, argv, "benstuvAET", long_options, NULL))
    > ---------------
    >
    > Which in turn does:
    > ---------------
    > void
    > close_stdout (void)
    > {
    > if (close_stream (stdout) != 0
    > && !(ignore_EPIPE && errno == EPIPE))
    > {
    > char const *write_error = _("write error");
    > if (file_name)
    > error (0, errno, "%s: %s", quotearg_colon (file_name),
    > write_error);
    > else
    > error (0, errno, "%s", write_error);
    >
    > _exit (exit_failure);
    > }
    >
    > if (close_stream (stderr) != 0)
    > _exit (exit_failure);
    > }
    > ---------------
    >
    > exit_failure is a global from libcoreutils.a which cat never changes
    > from the default, so it's always 1.
    >
    > (And of course error() is coreutils' own implementation rather than
    > glibc's because hey maybe you're not using glibc, but still, it's
    > there.)
    >
    > So it's /annoying/ to propagate the error from there programatically,
    > but it can work.

    Yes, I think we've all agreed we can do it ... it's now a question of
    whether we can stomach the ick factor of actually initiating a
    transaction in close ... I'm still feeling queasy.

    There are quite a few of these 'transactional blob' problems where we'd
    like to use a file/device approach because the data is just passed to
    something but have problems because the something wants all or nothing
    rather than chunks. I think all of us who work at the coal face on this
    are not enthused by an ioctl solution because of the need for
    non-standard tools to effect it.

    The alternative might be a two file approach (either in sysfs or a mini
    custom fs), one for load up data and the other for initiate transaction
    with the data errors (like overflow) being returned on the load up file
    and the transaction errors being returned on the write that initiates
    the transaction.

    My architectural sense is that transaction on close, provided we can
    make it a more universally accepted idea, has a lot of potential because
    it's more intuitive than the two file approach.

    James




    \
     
     \ /
      Last update: 2015-04-22 18:01    [W:3.131 / U:0.868 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site