Merge lp:~yuningdodo/systemd/systemd.trusty-proposed.lp1313522 into lp:ubuntu/trusty-proposed/systemd

[Yu Ning]

Apply the patch backported by Martin Pitt for bug #1313522 to trusty-proposed.

  [Martin Pitt]
  * Advertise hibernation only if there's enough free swap. Patches backported
    from current upstream. (LP: #1313522)

[Yu Ning (yuningdodo)]

In fact what I want to do is a SRU to trusty, please let me know if I'm doing it in the wrong way. Thanks in advance.

[Martin Pitt (pitti)]

Uploaded, thanks!

=== added directory '.pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch'
=== added file '.pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/.timestamp'
=== added directory '.pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src'
=== added directory '.pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src/shared'
=== added file '.pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src/shared/fileio.c'
--- .pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src/shared/fileio.c	1970-01-01 00:00:00 +0000
+++ .pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src/shared/fileio.c	2014-05-07 11:49:49 +0000
@@ -0,0 +1,596 @@
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
+
+/***
+  This file is part of systemd.
+
+  Copyright 2010 Lennart Poettering
+
+  systemd is free software; you can redistribute it and/or modify it
+  under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+
+  systemd is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with systemd; If not, see <http://www.gnu.org/licenses/>.
+***/
+
+#include <unistd.h>
+#include "fileio.h"
+#include "util.h"
+#include "strv.h"
+
+
+int write_string_to_file(FILE *f, const char *line) {
+        errno = 0;
+        fputs(line, f);
+        if (!endswith(line, "\n"))
+                fputc('\n', f);
+
+        fflush(f);
+
+        if (ferror(f))
+                return errno ? -errno : -EIO;
+
+        return 0;
+}
+
+int write_string_file(const char *fn, const char *line) {
+        _cleanup_fclose_ FILE *f = NULL;
+
+        assert(fn);
+        assert(line);
+
+        f = fopen(fn, "we");
+        if (!f)
+                return -errno;
+
+        return write_string_to_file(f, line);
+}
+
+int write_string_file_atomic(const char *fn, const char *line) {
+        _cleanup_fclose_ FILE *f = NULL;
+        _cleanup_free_ char *p = NULL;
+        int r;
+
+        assert(fn);
+        assert(line);
+
+        r = fopen_temporary(fn, &f, &p);
+        if (r < 0)
+                return r;
+
+        fchmod_umask(fileno(f), 0644);
+
+        errno = 0;
+        fputs(line, f);
+        if (!endswith(line, "\n"))
+                fputc('\n', f);
+
+        fflush(f);
+
+        if (ferror(f))
+                r = errno ? -errno : -EIO;
+        else {
+                if (rename(p, fn) < 0)
+                        r = -errno;
+                else
+                        r = 0;
+        }
+
+        if (r < 0)
+                unlink(p);
+
+        return r;
+}
+
+int read_one_line_file(const char *fn, char **line) {
+        _cleanup_fclose_ FILE *f = NULL;
+        char t[LINE_MAX], *c;
+
+        assert(fn);
+        assert(line);
+
+        f = fopen(fn, "re");
+        if (!f)
+                return -errno;
+
+        if (!fgets(t, sizeof(t), f)) {
+
+                if (ferror(f))
+                        return errno ? -errno : -EIO;
+
+                t[0] = 0;
+        }
+
+        c = strdup(t);
+        if (!c)
+                return -ENOMEM;
+        truncate_nl(c);
+
+        *line = c;
+        return 0;
+}
+
+int read_full_file(const char *fn, char **contents, size_t *size) {
+        _cleanup_fclose_ FILE *f = NULL;
+        size_t n, l;
+        _cleanup_free_ char *buf = NULL;
+        struct stat st;
+
+        assert(fn);
+        assert(contents);
+
+        f = fopen(fn, "re");
+        if (!f)
+                return -errno;
+
+        if (fstat(fileno(f), &st) < 0)
+                return -errno;
+
+        /* Safety check */
+        if (st.st_size > 4*1024*1024)
+                return -E2BIG;
+
+        n = st.st_size > 0 ? st.st_size : LINE_MAX;
+        l = 0;
+
+        for (;;) {
+                char *t;
+                size_t k;
+
+                t = realloc(buf, n+1);
+                if (!t)
+                        return -ENOMEM;
+
+                buf = t;
+                k = fread(buf + l, 1, n - l, f);
+
+                if (k <= 0) {
+                        if (ferror(f))
+                                return -errno;
+
+                        break;
+                }
+
+                l += k;
+                n *= 2;
+
+                /* Safety check */
+                if (n > 4*1024*1024)
+                        return -E2BIG;
+        }
+
+        buf[l] = 0;
+        *contents = buf;
+        buf = NULL;
+
+        if (size)
+                *size = l;
+
+        return 0;
+}
+
+static int parse_env_file_internal(
+                const char *fname,
+                const char *newline,
+                int (*push) (const char *key, char *value, void *userdata),
+                void *userdata) {
+
+        _cleanup_free_ char *contents = NULL, *key = NULL;
+        size_t key_alloc = 0, n_key = 0, value_alloc = 0, n_value = 0, last_value_whitespace = (size_t) -1, last_key_whitespace = (size_t) -1;
+        char *p, *value = NULL;
+        int r;
+
+        enum {
+                PRE_KEY,
+                KEY,
+                PRE_VALUE,
+                VALUE,
+                VALUE_ESCAPE,
+                SINGLE_QUOTE_VALUE,
+                SINGLE_QUOTE_VALUE_ESCAPE,
+                DOUBLE_QUOTE_VALUE,
+                DOUBLE_QUOTE_VALUE_ESCAPE,
+                COMMENT,
+                COMMENT_ESCAPE
+        } state = PRE_KEY;
+
+        assert(fname);
+        assert(newline);
+
+        r = read_full_file(fname, &contents, NULL);
+        if (r < 0)
+                return r;
+
+        for (p = contents; *p; p++) {
+                char c = *p;
+
+                switch (state) {
+
+                case PRE_KEY:
+                        if (strchr(COMMENTS, c))
+                                state = COMMENT;
+                        else if (!strchr(WHITESPACE, c)) {
+                                state = KEY;
+                                last_key_whitespace = (size_t) -1;
+
+                                if (!greedy_realloc((void**) &key, &key_alloc, n_key+2)) {
+                                        r = -ENOMEM;
+                                        goto fail;
+                                }
+
+                                key[n_key++] = c;
+                        }
+                        break;
+
+                case KEY:
+                        if (strchr(newline, c)) {
+                                state = PRE_KEY;
+                                n_key = 0;
+                        } else if (c == '=') {
+                                state = PRE_VALUE;
+                                last_value_whitespace = (size_t) -1;
+                        } else {
+                                if (!strchr(WHITESPACE, c))
+                                        last_key_whitespace = (size_t) -1;
+                                else if (last_key_whitespace == (size_t) -1)
+                                         last_key_whitespace = n_key;
+
+                                if (!greedy_realloc((void**) &key, &key_alloc, n_key+2)) {
+                                        r = -ENOMEM;
+                                        goto fail;
+                                }
+
+                                key[n_key++] = c;
+                        }
+
+                        break;
+
+                case PRE_VALUE:
+                        if (strchr(newline, c)) {
+                                state = PRE_KEY;
+                                key[n_key] = 0;
+
+                                if (value)
+                                        value[n_value] = 0;
+
+                                /* strip trailing whitespace from key */
+                                if (last_key_whitespace != (size_t) -1)
+                                        key[last_key_whitespace] = 0;
+
+                                r = push(key, value, userdata);
+                                if (r < 0)
+                                        goto fail;
+
+                                n_key = 0;
+                                value = NULL;
+                                value_alloc = n_value = 0;
+
+                        } else if (c == '\'')
+                                state = SINGLE_QUOTE_VALUE;
+                        else if (c == '\"')
+                                state = DOUBLE_QUOTE_VALUE;
+                        else if (c == '\\')
+                                state = VALUE_ESCAPE;
+                        else if (!strchr(WHITESPACE, c)) {
+                                state = VALUE;
+
+                                if (!greedy_realloc((void**) &value, &value_alloc, n_value+2)) {
+                                        r = -ENOMEM;
+                                        goto fail;
+                                }
+
+                                value[n_value++] = c;
+                        }
+
+                        break;
+
+                case VALUE:
+                        if (strchr(newline, c)) {
+                                state = PRE_KEY;
+
+                                key[n_key] = 0;
+
+                                if (value)
+                                        value[n_value] = 0;
+
+                                /* Chomp off trailing whitespace from value */
+                                if (last_value_whitespace != (size_t) -1)
+                                        value[last_value_whitespace] = 0;
+
+                                /* strip trailing whitespace from key */
+                                if (last_key_whitespace != (size_t) -1)
+                                        key[last_key_whitespace] = 0;
+
+                                r = push(key, value, userdata);
+                                if (r < 0)
+                                        goto fail;
+
+                                n_key = 0;
+                                value = NULL;
+                                value_alloc = n_value = 0;
+
+                        } else if (c == '\\') {
+                                state = VALUE_ESCAPE;
+                                last_value_whitespace = (size_t) -1;
+                        } else {
+                                if (!strchr(WHITESPACE, c))
+                                        last_value_whitespace = (size_t) -1;
+                                else if (last_value_whitespace == (size_t) -1)
+                                        last_value_whitespace = n_value;
+
+                                if (!greedy_realloc((void**) &value, &value_alloc, n_value+2)) {
+                                        r = -ENOMEM;
+                                        goto fail;
+                                }
+
+                                value[n_value++] = c;
+                        }
+
+                        break;
+
+                case VALUE_ESCAPE:
+                        state = VALUE;
+
+                        if (!strchr(newline, c)) {
+                                /* Escaped newlines we eat up entirely */
+                                if (!greedy_realloc((void**) &value, &value_alloc, n_value+2)) {
+                                        r = -ENOMEM;
+                                        goto fail;
+                                }
+
+                                value[n_value++] = c;
+                        }
+                        break;
+
+                case SINGLE_QUOTE_VALUE:
+                        if (c == '\'')
+                                state = PRE_VALUE;
+                        else if (c == '\\')
+                                state = SINGLE_QUOTE_VALUE_ESCAPE;
+                        else {
+                                if (!greedy_realloc((void**) &value, &value_alloc, n_value+2)) {
+                                        r = -ENOMEM;
+                                        goto fail;
+                                }
+
+                                value[n_value++] = c;
+                        }
+
+                        break;
+
+                case SINGLE_QUOTE_VALUE_ESCAPE:
+                        state = SINGLE_QUOTE_VALUE;
+
+                        if (!strchr(newline, c)) {
+                                if (!greedy_realloc((void**) &value, &value_alloc, n_value+2)) {
+                                        r = -ENOMEM;
+                                        goto fail;
+                                }
+
+                                value[n_value++] = c;
+                        }
+                        break;
+
+                case DOUBLE_QUOTE_VALUE:
+                        if (c == '\"')
+                                state = PRE_VALUE;
+                        else if (c == '\\')
+                                state = DOUBLE_QUOTE_VALUE_ESCAPE;
+                        else {
+                                if (!greedy_realloc((void**) &value, &value_alloc, n_value+2)) {
+                                        r = -ENOMEM;
+                                        goto fail;
+                                }
+
+                                value[n_value++] = c;
+                        }
+
+                        break;
+
+                case DOUBLE_QUOTE_VALUE_ESCAPE:
+                        state = DOUBLE_QUOTE_VALUE;
+
+                        if (!strchr(newline, c)) {
+                                if (!greedy_realloc((void**) &value, &value_alloc, n_value+2)) {
+                                        r = -ENOMEM;
+                                        goto fail;
+                                }
+
+                                value[n_value++] = c;
+                        }
+                        break;
+
+                case COMMENT:
+                        if (c == '\\')
+                                state = COMMENT_ESCAPE;
+                        else if (strchr(newline, c))
+                                state = PRE_KEY;
+                        break;
+
+                case COMMENT_ESCAPE:
+                        state = COMMENT;
+                        break;
+                }
+        }
+
+        if (state == PRE_VALUE ||
+            state == VALUE ||
+            state == VALUE_ESCAPE ||
+            state == SINGLE_QUOTE_VALUE ||
+            state == SINGLE_QUOTE_VALUE_ESCAPE ||
+            state == DOUBLE_QUOTE_VALUE ||
+            state == DOUBLE_QUOTE_VALUE_ESCAPE) {
+
+                key[n_key] = 0;
+
+                if (value)
+                        value[n_value] = 0;
+
+                if (state == VALUE)
+                        if (last_value_whitespace != (size_t) -1)
+                                value[last_value_whitespace] = 0;
+
+                /* strip trailing whitespace from key */
+                if (last_key_whitespace != (size_t) -1)
+                        key[last_key_whitespace] = 0;
+
+                r = push(key, value, userdata);
+                if (r < 0)
+                        goto fail;
+        }
+
+        return 0;
+
+fail:
+        free(value);
+        return r;
+}
+
+static int parse_env_file_push(const char *key, char *value, void *userdata) {
+        const char *k;
+        va_list* ap = (va_list*) userdata;
+        va_list aq;
+
+        va_copy(aq, *ap);
+
+        while ((k = va_arg(aq, const char *))) {
+                char **v;
+
+                v = va_arg(aq, char **);
+
+                if (streq(key, k)) {
+                        va_end(aq);
+                        free(*v);
+                        *v = value;
+                        return 1;
+                }
+        }
+
+        va_end(aq);
+
+        free(value);
+        return 0;
+}
+
+int parse_env_file(
+                const char *fname,
+                const char *newline, ...) {
+
+        va_list ap;
+        int r;
+
+        if (!newline)
+                newline = NEWLINE;
+
+        va_start(ap, newline);
+        r = parse_env_file_internal(fname, newline, parse_env_file_push, &ap);
+        va_end(ap);
+
+        return r;
+}
+
+static int load_env_file_push(const char *key, char *value, void *userdata) {
+        char ***m = userdata;
+        char *p;
+        int r;
+
+        p = strjoin(key, "=", strempty(value), NULL);
+        if (!p)
+                return -ENOMEM;
+
+        r = strv_push(m, p);
+        if (r < 0) {
+                free(p);
+                return r;
+        }
+
+        free(value);
+        return 0;
+}
+
+int load_env_file(const char *fname, const char *newline, char ***rl) {
+        char **m = NULL;
+        int r;
+
+        if (!newline)
+                newline = NEWLINE;
+
+        r = parse_env_file_internal(fname, newline, load_env_file_push, &m);
+        if (r < 0) {
+                strv_free(m);
+                return r;
+        }
+
+        *rl = m;
+        return 0;
+}
+
+static void write_env_var(FILE *f, const char *v) {
+        const char *p;
+
+        p = strchr(v, '=');
+        if (!p) {
+                /* Fallback */
+                fputs(v, f);
+                fputc('\n', f);
+                return;
+        }
+
+        p++;
+        fwrite(v, 1, p-v, f);
+
+        if (string_has_cc(p) || chars_intersect(p, WHITESPACE "\'\"\\`$")) {
+                fputc('\"', f);
+
+                for (; *p; p++) {
+                        if (strchr("\'\"\\`$", *p))
+                                fputc('\\', f);
+
+                        fputc(*p, f);
+                }
+
+                fputc('\"', f);
+        } else
+                fputs(p, f);
+
+        fputc('\n', f);
+}
+
+int write_env_file(const char *fname, char **l) {
+        char **i;
+        _cleanup_free_ char *p = NULL;
+        _cleanup_fclose_ FILE *f = NULL;
+        int r;
+
+        r = fopen_temporary(fname, &f, &p);
+        if (r < 0)
+                return r;
+
+        fchmod_umask(fileno(f), 0644);
+
+        errno = 0;
+        STRV_FOREACH(i, l)
+                write_env_var(f, *i);
+
+        fflush(f);
+
+        if (ferror(f))
+                r = errno ? -errno : -EIO;
+        else {
+                if (rename(p, fname) < 0)
+                        r = -errno;
+                else
+                        r = 0;
+        }
+
+        if (r < 0)
+                unlink(p);
+
+        return r;
+}

=== added file '.pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src/shared/fileio.h'
--- .pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src/shared/fileio.h	1970-01-01 00:00:00 +0000
+++ .pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src/shared/fileio.h	2014-05-07 11:49:49 +0000
@@ -0,0 +1,37 @@
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
+
+#pragma once
+
+/***
+  This file is part of systemd.
+
+  Copyright 2010 Lennart Poettering
+
+  systemd is free software; you can redistribute it and/or modify it
+  under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+
+  systemd is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with systemd; If not, see <http://www.gnu.org/licenses/>.
+***/
+#include <stddef.h>
+#include <stdio.h>
+
+#include "macro.h"
+
+int write_string_to_file(FILE *f, const char *line);
+int write_string_file(const char *fn, const char *line);
+int write_string_file_atomic(const char *fn, const char *line);
+
+int read_one_line_file(const char *fn, char **line);
+int read_full_file(const char *fn, char **contents, size_t *size);
+
+int parse_env_file(const char *fname, const char *separator, ...) _sentinel_;
+int load_env_file(const char *fname, const char *separator, char ***l);
+int write_env_file(const char *fname, char **l);

=== added file '.pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src/shared/sleep-config.c'
--- .pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src/shared/sleep-config.c	1970-01-01 00:00:00 +0000
+++ .pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src/shared/sleep-config.c	2014-05-07 11:49:49 +0000
@@ -0,0 +1,179 @@
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
+
+/***
+  This file is part of systemd.
+
+  Copyright 2013 Zbigniew Jędrzejewski-Szmek
+
+  systemd is free software; you can redistribute it and/or modify it
+  under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+
+  systemd is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with systemd; If not, see <http://www.gnu.org/licenses/>.
+***/
+
+#include <stdio.h>
+
+#include "conf-parser.h"
+#include "sleep-config.h"
+#include "fileio.h"
+#include "log.h"
+#include "strv.h"
+#include "util.h"
+
+int parse_sleep_config(const char *verb, char ***modes, char ***states) {
+        _cleanup_strv_free_ char
+                **suspend_mode = NULL, **suspend_state = NULL,
+                **hibernate_mode = NULL, **hibernate_state = NULL,
+                **hybrid_mode = NULL, **hybrid_state = NULL;
+
+        const ConfigTableItem items[] = {
+                { "Sleep",   "SuspendMode",      config_parse_strv,  0, &suspend_mode  },
+                { "Sleep",   "SuspendState",     config_parse_strv,  0, &suspend_state },
+                { "Sleep",   "HibernateMode",    config_parse_strv,  0, &hibernate_mode  },
+                { "Sleep",   "HibernateState",   config_parse_strv,  0, &hibernate_state },
+                { "Sleep",   "HybridSleepMode",  config_parse_strv,  0, &hybrid_mode  },
+                { "Sleep",   "HybridSleepState", config_parse_strv,  0, &hybrid_state },
+                {}};
+
+        int r;
+        FILE _cleanup_fclose_ *f;
+
+        f = fopen(PKGSYSCONFDIR "/sleep.conf", "re");
+        if (!f)
+                log_full(errno == ENOENT ? LOG_DEBUG: LOG_WARNING,
+                         "Failed to open configuration file " PKGSYSCONFDIR "/sleep.conf: %m");
+        else {
+                r = config_parse(NULL, PKGSYSCONFDIR "/sleep.conf", f, "Sleep\0",
+                                 config_item_table_lookup, (void*) items, false, false, NULL);
+                if (r < 0)
+                        log_warning("Failed to parse configuration file: %s", strerror(-r));
+        }
+
+        if (streq(verb, "suspend")) {
+                /* empty by default */
+                *modes = suspend_mode;
+
+                if (suspend_state)
+                        *states = suspend_state;
+                else
+                        *states = strv_split_nulstr("mem\0standby\0freeze\0");
+
+                suspend_mode = suspend_state = NULL;
+        } else if (streq(verb, "hibernate")) {
+                if (hibernate_mode)
+                        *modes = hibernate_mode;
+                else
+                        *modes = strv_split_nulstr("platform\0shutdown\0");
+
+                if (hibernate_state)
+                        *states = hibernate_state;
+                else
+                        *states = strv_split_nulstr("disk\0");
+
+                hibernate_mode = hibernate_state = NULL;
+        } else if (streq(verb, "hybrid-sleep")) {
+                if (hybrid_mode)
+                        *modes = hybrid_mode;
+                else
+                        *modes = strv_split_nulstr("suspend\0platform\0shutdown\0");
+
+                if (hybrid_state)
+                        *states = hybrid_state;
+                else
+                        *states = strv_split_nulstr("disk\0");
+
+                hybrid_mode = hybrid_state = NULL;
+        } else
+                assert_not_reached("what verb");
+
+        if (!modes || !states) {
+                strv_free(*modes);
+                strv_free(*states);
+                return log_oom();
+        }
+
+        return 0;
+}
+
+int can_sleep_state(char **types) {
+        char *w, *state, **type;
+        int r;
+        _cleanup_free_ char *p = NULL;
+
+        if (strv_isempty(types))
+                return true;
+
+        /* If /sys is read-only we cannot sleep */
+        if (access("/sys/power/state", W_OK) < 0)
+                return false;
+
+        r = read_one_line_file("/sys/power/state", &p);
+        if (r < 0)
+                return false;
+
+        STRV_FOREACH(type, types) {
+                size_t l, k;
+
+                k = strlen(*type);
+                FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state)
+                        if (l == k && memcmp(w, *type, l) == 0)
+                                return true;
+        }
+
+        return false;
+}
+
+int can_sleep_disk(char **types) {
+        char *w, *state, **type;
+        int r;
+        _cleanup_free_ char *p = NULL;
+
+        if (strv_isempty(types))
+                return true;
+
+        /* If /sys is read-only we cannot sleep */
+        if (access("/sys/power/disk", W_OK) < 0)
+                return false;
+
+        r = read_one_line_file("/sys/power/disk", &p);
+        if (r < 0)
+                return false;
+
+        STRV_FOREACH(type, types) {
+                size_t l, k;
+
+                k = strlen(*type);
+                FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state) {
+                        if (l == k && memcmp(w, *type, l) == 0)
+                                return true;
+
+                        if (l == k + 2 && w[0] == '[' && memcmp(w + 1, *type, l - 2) == 0 && w[l-1] == ']')
+                                return true;
+                }
+        }
+
+        return false;
+}
+
+int can_sleep(const char *verb) {
+        _cleanup_strv_free_ char **modes = NULL, **states = NULL;
+        int r;
+
+        assert(streq(verb, "suspend") ||
+               streq(verb, "hibernate") ||
+               streq(verb, "hybrid-sleep"));
+
+        r = parse_sleep_config(verb, &modes, &states);
+        if (r < 0)
+                return false;
+
+        return can_sleep_state(states) && can_sleep_disk(modes);
+}

=== added directory '.pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src/test'
=== added file '.pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src/test/test-fileio.c'
--- .pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src/test/test-fileio.c	1970-01-01 00:00:00 +0000
+++ .pc/Advertise-hibernation-only-if-there-s-enough-free-sw.patch/src/test/test-fileio.c	2014-05-07 11:49:49 +0000
@@ -0,0 +1,145 @@
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
+
+/***
+  This file is part of systemd.
+
+  Copyright 2013 Lennart Poettering
+
+  systemd is free software; you can redistribute it and/or modify it
+  under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+
+  systemd is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with systemd; If not, see <http://www.gnu.org/licenses/>.
+***/
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "util.h"
+#include "fileio.h"
+#include "strv.h"
+#include "env-util.h"
+
+static void test_parse_env_file(void) {
+        char t[] = "/tmp/test-parse-env-file-XXXXXX";
+        int fd, r;
+        FILE *f;
+        _cleanup_free_ char *one = NULL, *two = NULL, *three = NULL, *four = NULL, *five = NULL,
+                        *six = NULL, *seven = NULL, *eight = NULL, *nine = NULL, *ten = NULL;
+        _cleanup_strv_free_ char **a = NULL, **b = NULL;
+        char **i;
+        unsigned k;
+
+        fd = mkostemp(t, O_CLOEXEC);
+        assert_se(fd >= 0);
+
+        f = fdopen(fd, "w");
+        assert_se(f);
+
+        fputs("one=BAR   \n"
+              "# comment\n"
+              " # comment \n"
+              " ; comment \n"
+              "  two   =   bar    \n"
+              "invalid line\n"
+              "invalid line #comment\n"
+              "three = \"333\n"
+              "xxxx\"\n"
+              "four = \'44\\\"44\'\n"
+              "five = \'55\\\'55\' \"FIVE\" cinco   \n"
+              "six = seis sechs\\\n"
+              " sis\n"
+              "seven=\"sevenval\" #nocomment\n"
+              "eight=eightval #nocomment\n"
+              "export nine=nineval\n"
+              "ten=", f);
+
+        fflush(f);
+        fclose(f);
+
+        r = load_env_file(t, NULL, &a);
+        assert_se(r >= 0);
+
+        STRV_FOREACH(i, a)
+                log_info("Got: <%s>", *i);
+
+        assert_se(streq(a[0], "one=BAR"));
+        assert_se(streq(a[1], "two=bar"));
+        assert_se(streq(a[2], "three=333\nxxxx"));
+        assert_se(streq(a[3], "four=44\"44"));
+        assert_se(streq(a[4], "five=55\'55FIVEcinco"));
+        assert_se(streq(a[5], "six=seis sechs sis"));
+        assert_se(streq(a[6], "seven=sevenval#nocomment"));
+        assert_se(streq(a[7], "eight=eightval #nocomment"));
+        assert_se(streq(a[8], "export nine=nineval"));
+        assert_se(streq(a[9], "ten="));
+        assert_se(a[10] == NULL);
+
+        strv_env_clean_log(a, "/tmp/test-fileio");
+
+        k = 0;
+        STRV_FOREACH(i, b) {
+                log_info("Got2: <%s>", *i);
+                assert_se(streq(*i, a[k++]));
+        }
+
+        r = parse_env_file(
+                        t, NULL,
+                       "one", &one,
+                       "two", &two,
+                       "three", &three,
+                       "four", &four,
+                       "five", &five,
+                       "six", &six,
+                       "seven", &seven,
+                       "eight", &eight,
+                       "export nine", &nine,
+                       "ten", &ten,
+                       NULL);
+
+        assert_se(r >= 0);
+
+        log_info("one=[%s]", strna(one));
+        log_info("two=[%s]", strna(two));
+        log_info("three=[%s]", strna(three));
+        log_info("four=[%s]", strna(four));
+        log_info("five=[%s]", strna(five));
+        log_info("six=[%s]", strna(six));
+        log_info("seven=[%s]", strna(seven));
+        log_info("eight=[%s]", strna(eight));
+        log_info("export nine=[%s]", strna(nine));
+        log_info("ten=[%s]", strna(nine));
+
+        assert_se(streq(one, "BAR"));
+        assert_se(streq(two, "bar"));
+        assert_se(streq(three, "333\nxxxx"));
+        assert_se(streq(four, "44\"44"));
+        assert_se(streq(five, "55\'55FIVEcinco"));
+        assert_se(streq(six, "seis sechs sis"));
+        assert_se(streq(seven, "sevenval#nocomment"));
+        assert_se(streq(eight, "eightval #nocomment"));
+        assert_se(streq(nine, "nineval"));
+        assert_se(ten == NULL);
+
+        r = write_env_file("/tmp/test-fileio", a);
+        assert_se(r >= 0);
+
+        r = load_env_file("/tmp/test-fileio", NULL, &b);
+        assert_se(r >= 0);
+
+        unlink(t);
+        unlink("/tmp/test-fileio");
+}
+
+int main(int argc, char *argv[]) {
+        test_parse_env_file();
+        return 0;
+}

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2014-03-19 21:34:25 +0000
+++ .pc/applied-patches	2014-05-07 11:49:49 +0000
@@ -17,3 +17,4 @@
 ubuntu-logind-controllers.patch
 fix-ftbfs.patch
 add-cgmanager-support
+Advertise-hibernation-only-if-there-s-enough-free-sw.patch

=== modified file 'debian/changelog'
--- debian/changelog	2014-04-14 16:20:35 +0000
+++ debian/changelog	2014-05-07 11:49:49 +0000
@@ -1,3 +1,11 @@
+systemd (204-5ubuntu20.1) trusty-proposed; urgency=medium
+
+  [Martin Pitt]
+  * Advertise hibernation only if there's enough free swap. Patches backported
+    from current upstream. (LP: #1313522)
+
+ -- Yu Ning <[e-mail]>  Wed, 07 May 2014 19:41:29 +0800
+
 systemd (204-5ubuntu20) trusty; urgency=medium
 
   * systemd-logind.conf: Don't use the limit stanza which fails the

=== added file 'debian/patches/Advertise-hibernation-only-if-there-s-enough-free-sw.patch'
--- debian/patches/Advertise-hibernation-only-if-there-s-enough-free-sw.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/Advertise-hibernation-only-if-there-s-enough-free-sw.patch	2014-05-07 11:49:49 +0000
@@ -0,0 +1,289 @@
+From: =?utf-8?q?Zbigniew_J=C4=99drzejewski-Szmek?= <[e-mail]>
+Date: Fri, 13 Sep 2013 19:41:52 -0400
+Subject: Advertise hibernation only if there's enough free swap
+
+Cherry-pick various upstream patches starting from 69ab80881 and 442e00839
+to check whether there is swap available for hibernation.
+
+Bug-Ubuntu: https://launchpad.net/bugs/1313522
+---
+ src/shared/fileio.c       |  34 +++++++++++++
+ src/shared/fileio.h       |   2 +
+ src/shared/sleep-config.c | 126 +++++++++++++++++++++++++++++++++++++++-------
+ src/shared/util.c         |   1 -
+ src/test/test-fileio.c    |  24 +++++++++
+ src/test/test-sleep.c     |  16 +++---
+ 6 files changed, 175 insertions(+), 28 deletions(-)
+
+diff --git a/src/shared/fileio.c b/src/shared/fileio.c
+index ad068bf..9af284d 100644
+--- a/src/shared/fileio.c
++++ b/src/shared/fileio.c
+@@ -594,3 +594,37 @@ int write_env_file(const char *fname, char **l) {
+ 
+         return r;
+ }
++
++/**
++ * Retrieve one field from a file like /proc/self/status.
++ * pattern should start with '\n' and end with ':'. Whitespace
++ * after ':' will be skipped. field must be freed afterwards.
++ */
++int get_status_field(const char *filename, const char *pattern, char **field) {
++        _cleanup_free_ char *status = NULL;
++        char *t;
++        size_t len;
++        int r;
++
++        assert(filename);
++        assert(field);
++
++        r = read_full_file(filename, &status, NULL);
++        if (r < 0)
++                return r;
++
++        t = strstr(status, pattern);
++        if (!t)
++                return -ENOENT;
++
++        t += strlen(pattern);
++        t += strspn(t, WHITESPACE);
++
++        len = strcspn(t, WHITESPACE);
++
++        *field = strndup(t, len);
++        if (!*field)
++                return -ENOMEM;
++
++        return 0;
++}
+diff --git a/src/shared/fileio.h b/src/shared/fileio.h
+index 0ca6878..d8079ab 100644
+--- a/src/shared/fileio.h
++++ b/src/shared/fileio.h
+@@ -35,3 +35,5 @@ int read_full_file(const char *fn, char **contents, size_t *size);
+ int parse_env_file(const char *fname, const char *separator, ...) _sentinel_;
+ int load_env_file(const char *fname, const char *separator, char ***l);
+ int write_env_file(const char *fname, char **l);
++
++int get_status_field(const char *filename, const char *pattern, char **field);
+diff --git a/src/shared/sleep-config.c b/src/shared/sleep-config.c
+index cd3238b..cf1cd40 100644
+--- a/src/shared/sleep-config.c
++++ b/src/shared/sleep-config.c
+@@ -28,11 +28,14 @@
+ #include "strv.h"
+ #include "util.h"
+ 
+-int parse_sleep_config(const char *verb, char ***modes, char ***states) {
++#define USE(x, y) do{ (x) = (y); (y) = NULL; } while(0)
++
++int parse_sleep_config(const char *verb, char ***_modes, char ***_states) {
+         _cleanup_strv_free_ char
+                 **suspend_mode = NULL, **suspend_state = NULL,
+                 **hibernate_mode = NULL, **hibernate_state = NULL,
+                 **hybrid_mode = NULL, **hybrid_state = NULL;
++        char **modes, **states;
+ 
+         const ConfigTableItem items[] = {
+                 { "Sleep",   "SuspendMode",      config_parse_strv,  0, &suspend_mode  },
+@@ -59,47 +62,46 @@ int parse_sleep_config(const char *verb, char ***modes, char ***states) {
+ 
+         if (streq(verb, "suspend")) {
+                 /* empty by default */
+-                *modes = suspend_mode;
++                USE(modes, suspend_mode);
+ 
+                 if (suspend_state)
+-                        *states = suspend_state;
++                        USE(states, suspend_state);
+                 else
+-                        *states = strv_split_nulstr("mem\0standby\0freeze\0");
++                        states = strv_new("mem", "standby", "freeze", NULL);
+ 
+-                suspend_mode = suspend_state = NULL;
+         } else if (streq(verb, "hibernate")) {
+                 if (hibernate_mode)
+-                        *modes = hibernate_mode;
++                        USE(modes, hibernate_mode);
+                 else
+-                        *modes = strv_split_nulstr("platform\0shutdown\0");
++                        modes = strv_new("platform", "shutdown", NULL);
+ 
+                 if (hibernate_state)
+-                        *states = hibernate_state;
++                        USE(states, hibernate_state);
+                 else
+-                        *states = strv_split_nulstr("disk\0");
++                        states = strv_new("disk", NULL);
+ 
+-                hibernate_mode = hibernate_state = NULL;
+         } else if (streq(verb, "hybrid-sleep")) {
+                 if (hybrid_mode)
+-                        *modes = hybrid_mode;
++                        USE(modes, hybrid_mode);
+                 else
+-                        *modes = strv_split_nulstr("suspend\0platform\0shutdown\0");
++                        modes = strv_new("suspend", "platform", "shutdown", NULL);
+ 
+                 if (hybrid_state)
+-                        *states = hybrid_state;
++                        USE(states, hybrid_state);
+                 else
+-                        *states = strv_split_nulstr("disk\0");
++                        states = strv_new("disk", NULL);
+ 
+-                hybrid_mode = hybrid_state = NULL;
+         } else
+                 assert_not_reached("what verb");
+ 
+-        if (!modes || !states) {
+-                strv_free(*modes);
+-                strv_free(*states);
++        if ((!modes && !streq(verb, "suspend")) || !states) {
++                strv_free(modes);
++                strv_free(states);
+                 return log_oom();
+         }
+ 
++        *_modes = modes;
++        *_states = states;
+         return 0;
+ }
+ 
+@@ -163,6 +165,89 @@ int can_sleep_disk(char **types) {
+         return false;
+ }
+ 
++#define HIBERNATION_SWAP_THRESHOLD 0.98
++
++static int hibernation_partition_size(size_t *size, size_t *used) {
++        _cleanup_fclose_ FILE *f;
++        int i;
++
++        assert(size);
++        assert(used);
++
++        f = fopen("/proc/swaps", "re");
++        if (!f) {
++                log_full(errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
++                         "Failed to retrieve open /proc/swaps: %m");
++                assert(errno > 0);
++                return -errno;
++        }
++
++        (void) fscanf(f, "%*s %*s %*s %*s %*s\n");
++
++        for (i = 1;; i++) {
++                _cleanup_free_ char *dev = NULL, *type = NULL;
++                size_t size_field, used_field;
++                int k;
++
++                k = fscanf(f,
++                           "%ms "   /* device/file */
++                           "%ms "   /* type of swap */
++                           "%zd "   /* swap size */
++                           "%zd "   /* used */
++                           "%*i\n", /* priority */
++                           &dev, &type, &size_field, &used_field);
++                if (k != 4) {
++                        if (k == EOF)
++                                break;
++
++                        log_warning("Failed to parse /proc/swaps:%u", i);
++                        continue;
++                }
++
++                if (streq(type, "partition") && endswith(dev, "\\040(deleted)")) {
++                        log_warning("Ignoring deleted swapfile '%s'.", dev);
++                        continue;
++                }
++
++                *size = size_field;
++                *used = used_field;
++                return 0;
++        }
++
++        log_debug("No swap partitions were found.");
++        return -ENOSYS;
++}
++
++static bool enough_memory_for_hibernation(void) {
++        _cleanup_free_ char *active = NULL;
++        unsigned long long act = 0;
++        size_t size = 0, used = 0;
++        int r;
++
++        r = hibernation_partition_size(&size, &used);
++        if (r < 0)
++                return false;
++
++        r = get_status_field("/proc/meminfo", "\nActive(anon):", &active);
++        if (r < 0) {
++                log_error("Failed to retrieve Active(anon) from /proc/meminfo: %s", strerror(-r));
++                return false;
++        }
++
++        r = safe_atollu(active, &act);
++        if (r < 0) {
++                log_error("Failed to parse Active(anon) from /proc/meminfo: %s: %s",
++                          active, strerror(-r));
++                return false;
++        }
++
++        r = act <= (size - used) * HIBERNATION_SWAP_THRESHOLD;
++        log_debug("Hibernation is %spossible, Active(anon)=%llu kB, size=%zu kB, used=%zu kB, threshold=%.2g%%",
++                  r ? "" : "im", act, size, used, 100*HIBERNATION_SWAP_THRESHOLD);
++
++        return r;
++}
++
+ int can_sleep(const char *verb) {
+         _cleanup_strv_free_ char **modes = NULL, **states = NULL;
+         int r;
+@@ -175,5 +260,8 @@ int can_sleep(const char *verb) {
+         if (r < 0)
+                 return false;
+ 
+-        return can_sleep_state(states) && can_sleep_disk(modes);
++        if (!can_sleep_state(states) || !can_sleep_disk(modes))
++                return false;
++
++        return streq(verb, "suspend") || enough_memory_for_hibernation();
+ }
+diff --git a/src/test/test-fileio.c b/src/test/test-fileio.c
+index d56f7cc..8049efa 100644
+--- a/src/test/test-fileio.c
++++ b/src/test/test-fileio.c
+@@ -139,7 +139,31 @@ static void test_parse_env_file(void) {
+         unlink("/tmp/test-fileio");
+ }
+ 
++static void test_status_field(void) {
++        _cleanup_free_ char *t = NULL, *p = NULL, *s = NULL;
++        unsigned long long total, buffers;
++        int r;
++
++        assert_se(get_status_field("/proc/self/status", "\nThreads:", &t) == 0);
++        puts(t);
++        assert_se(streq(t, "1"));
++
++        r = get_status_field("/proc/meminfo", "MemTotal:", &p);
++        if (r == -ENOENT)
++                return;
++        assert(r == 0);
++        puts(p);
++        assert_se(safe_atollu(p, &total) == 0);
++
++        assert_se(get_status_field("/proc/meminfo", "\nBuffers:", &s) == 0);
++        puts(s);
++        assert_se(safe_atollu(s, &buffers) == 0);
++
++        assert(buffers < total);
++}
++
+ int main(int argc, char *argv[]) {
+         test_parse_env_file();
++        test_status_field();
+         return 0;
+ }

=== modified file 'debian/patches/series'
--- debian/patches/series	2014-03-19 21:34:25 +0000
+++ debian/patches/series	2014-05-07 11:49:49 +0000
@@ -25,3 +25,4 @@
 fix-ftbfs.patch
 
 add-cgmanager-support
+Advertise-hibernation-only-if-there-s-enough-free-sw.patch

=== modified file 'src/shared/fileio.c'
--- src/shared/fileio.c	2013-06-04 10:46:58 +0000
+++ src/shared/fileio.c	2014-05-07 11:49:49 +0000
@@ -594,3 +594,37 @@
 
         return r;
 }
+
+/**
+ * Retrieve one field from a file like /proc/self/status.
+ * pattern should start with '\n' and end with ':'. Whitespace
+ * after ':' will be skipped. field must be freed afterwards.
+ */
+int get_status_field(const char *filename, const char *pattern, char **field) {
+        _cleanup_free_ char *status = NULL;
+        char *t;
+        size_t len;
+        int r;
+
+        assert(filename);
+        assert(field);
+
+        r = read_full_file(filename, &status, NULL);
+        if (r < 0)
+                return r;
+
+        t = strstr(status, pattern);
+        if (!t)
+                return -ENOENT;
+
+        t += strlen(pattern);
+        t += strspn(t, WHITESPACE);
+
+        len = strcspn(t, WHITESPACE);
+
+        *field = strndup(t, len);
+        if (!*field)
+                return -ENOMEM;
+
+        return 0;
+}

=== modified file 'src/shared/fileio.h'
--- src/shared/fileio.h	2013-06-04 10:46:58 +0000
+++ src/shared/fileio.h	2014-05-07 11:49:49 +0000
@@ -35,3 +35,5 @@
 int parse_env_file(const char *fname, const char *separator, ...) _sentinel_;
 int load_env_file(const char *fname, const char *separator, char ***l);
 int write_env_file(const char *fname, char **l);
+
+int get_status_field(const char *filename, const char *pattern, char **field);

=== modified file 'src/shared/sleep-config.c'
--- src/shared/sleep-config.c	2013-06-04 10:46:58 +0000
+++ src/shared/sleep-config.c	2014-05-07 11:49:49 +0000
@@ -28,11 +28,14 @@
 #include "strv.h"
 #include "util.h"
 
-int parse_sleep_config(const char *verb, char ***modes, char ***states) {
+#define USE(x, y) do{ (x) = (y); (y) = NULL; } while(0)
+
+int parse_sleep_config(const char *verb, char ***_modes, char ***_states) {
         _cleanup_strv_free_ char
                 **suspend_mode = NULL, **suspend_state = NULL,
                 **hibernate_mode = NULL, **hibernate_state = NULL,
                 **hybrid_mode = NULL, **hybrid_state = NULL;
+        char **modes, **states;
 
         const ConfigTableItem items[] = {
                 { "Sleep",   "SuspendMode",      config_parse_strv,  0, &suspend_mode  },
@@ -59,47 +62,46 @@
 
         if (streq(verb, "suspend")) {
                 /* empty by default */
-                *modes = suspend_mode;
+                USE(modes, suspend_mode);
 
                 if (suspend_state)
-                        *states = suspend_state;
+                        USE(states, suspend_state);
                 else
-                        *states = strv_split_nulstr("mem\0standby\0freeze\0");
+                        states = strv_new("mem", "standby", "freeze", NULL);
 
-                suspend_mode = suspend_state = NULL;
         } else if (streq(verb, "hibernate")) {
                 if (hibernate_mode)
-                        *modes = hibernate_mode;
+                        USE(modes, hibernate_mode);
                 else
-                        *modes = strv_split_nulstr("platform\0shutdown\0");
+                        modes = strv_new("platform", "shutdown", NULL);
 
                 if (hibernate_state)
-                        *states = hibernate_state;
+                        USE(states, hibernate_state);
                 else
-                        *states = strv_split_nulstr("disk\0");
+                        states = strv_new("disk", NULL);
 
-                hibernate_mode = hibernate_state = NULL;
         } else if (streq(verb, "hybrid-sleep")) {
                 if (hybrid_mode)
-                        *modes = hybrid_mode;
+                        USE(modes, hybrid_mode);
                 else
-                        *modes = strv_split_nulstr("suspend\0platform\0shutdown\0");
+                        modes = strv_new("suspend", "platform", "shutdown", NULL);
 
                 if (hybrid_state)
-                        *states = hybrid_state;
+                        USE(states, hybrid_state);
                 else
-                        *states = strv_split_nulstr("disk\0");
+                        states = strv_new("disk", NULL);
 
-                hybrid_mode = hybrid_state = NULL;
         } else
                 assert_not_reached("what verb");
 
-        if (!modes || !states) {
-                strv_free(*modes);
-                strv_free(*states);
+        if ((!modes && !streq(verb, "suspend")) || !states) {
+                strv_free(modes);
+                strv_free(states);
                 return log_oom();
         }
 
+        *_modes = modes;
+        *_states = states;
         return 0;
 }
 
@@ -163,6 +165,89 @@
         return false;
 }
 
+#define HIBERNATION_SWAP_THRESHOLD 0.98
+
+static int hibernation_partition_size(size_t *size, size_t *used) {
+        _cleanup_fclose_ FILE *f;
+        int i;
+
+        assert(size);
+        assert(used);
+
+        f = fopen("/proc/swaps", "re");
+        if (!f) {
+                log_full(errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
+                         "Failed to retrieve open /proc/swaps: %m");
+                assert(errno > 0);
+                return -errno;
+        }
+
+        (void) fscanf(f, "%*s %*s %*s %*s %*s\n");
+
+        for (i = 1;; i++) {
+                _cleanup_free_ char *dev = NULL, *type = NULL;
+                size_t size_field, used_field;
+                int k;
+
+                k = fscanf(f,
+                           "%ms "   /* device/file */
+                           "%ms "   /* type of swap */
+                           "%zd "   /* swap size */
+                           "%zd "   /* used */
+                           "%*i\n", /* priority */
+                           &dev, &type, &size_field, &used_field);
+                if (k != 4) {
+                        if (k == EOF)
+                                break;
+
+                        log_warning("Failed to parse /proc/swaps:%u", i);
+                        continue;
+                }
+
+                if (streq(type, "partition") && endswith(dev, "\\040(deleted)")) {
+                        log_warning("Ignoring deleted swapfile '%s'.", dev);
+                        continue;
+                }
+
+                *size = size_field;
+                *used = used_field;
+                return 0;
+        }
+
+        log_debug("No swap partitions were found.");
+        return -ENOSYS;
+}
+
+static bool enough_memory_for_hibernation(void) {
+        _cleanup_free_ char *active = NULL;
+        unsigned long long act = 0;
+        size_t size = 0, used = 0;
+        int r;
+
+        r = hibernation_partition_size(&size, &used);
+        if (r < 0)
+                return false;
+
+        r = get_status_field("/proc/meminfo", "\nActive(anon):", &active);
+        if (r < 0) {
+                log_error("Failed to retrieve Active(anon) from /proc/meminfo: %s", strerror(-r));
+                return false;
+        }
+
+        r = safe_atollu(active, &act);
+        if (r < 0) {
+                log_error("Failed to parse Active(anon) from /proc/meminfo: %s: %s",
+                          active, strerror(-r));
+                return false;
+        }
+
+        r = act <= (size - used) * HIBERNATION_SWAP_THRESHOLD;
+        log_debug("Hibernation is %spossible, Active(anon)=%llu kB, size=%zu kB, used=%zu kB, threshold=%.2g%%",
+                  r ? "" : "im", act, size, used, 100*HIBERNATION_SWAP_THRESHOLD);
+
+        return r;
+}
+
 int can_sleep(const char *verb) {
         _cleanup_strv_free_ char **modes = NULL, **states = NULL;
         int r;
@@ -175,5 +260,8 @@
         if (r < 0)
                 return false;
 
-        return can_sleep_state(states) && can_sleep_disk(modes);
+        if (!can_sleep_state(states) || !can_sleep_disk(modes))
+                return false;
+
+        return streq(verb, "suspend") || enough_memory_for_hibernation();
 }

=== modified file 'src/test/test-fileio.c'
--- src/test/test-fileio.c	2013-04-29 17:29:24 +0000
+++ src/test/test-fileio.c	2014-05-07 11:49:49 +0000
@@ -139,7 +139,31 @@
         unlink("/tmp/test-fileio");
 }
 
+static void test_status_field(void) {
+        _cleanup_free_ char *t = NULL, *p = NULL, *s = NULL;
+        unsigned long long total, buffers;
+        int r;
+
+        assert_se(get_status_field("/proc/self/status", "\nThreads:", &t) == 0);
+        puts(t);
+        assert_se(streq(t, "1"));
+
+        r = get_status_field("/proc/meminfo", "MemTotal:", &p);
+        if (r == -ENOENT)
+                return;
+        assert(r == 0);
+        puts(p);
+        assert_se(safe_atollu(p, &total) == 0);
+
+        assert_se(get_status_field("/proc/meminfo", "\nBuffers:", &s) == 0);
+        puts(s);
+        assert_se(safe_atollu(s, &buffers) == 0);
+
+        assert(buffers < total);
+}
+
 int main(int argc, char *argv[]) {
         test_parse_env_file();
+        test_status_field();
         return 0;
 }