Merge branch 'upstream' into bugfix-video

Update bugfix-video branch to 2.5-rc1
so I don't have to again resolve the
conflict in these patches vs. upstream.

Conflicts:
	drivers/gpu/drm/gma500/psb_drv.c

	text conflict: add comment vs delete neighboring line

	keep just this:
	/* igd_opregion_init(&dev_priv->opregion_dev); */
	/* acpi_video_register(); */

Signed-off-by: Len Brown <len.brown@intel.com>

1 files changed, 492 insertions, 0 deletions

diff --git a/tools/testing/selftests/mqueue/mq_open_tests.c b/tools/testing/selftests/mqueue/mq_open_tests.c
new file mode 100644
index 000000000000..711cc2923047
--- /dev/null
+++ b/tools/testing/selftests/mqueue/mq_open_tests.c
@@ -0,0 +1,492 @@
+/*
+ * This application is Copyright 2012 Red Hat, Inc.
+ *      Doug Ledford <dledford@redhat.com>
+ *
+ * mq_open_tests is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * mq_open_tests 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 General Public License for more details.
+ *
+ * For the full text of the license, see <http://www.gnu.org/licenses/>.
+ *
+ * mq_open_tests.c
+ *   Tests the various situations that should either succeed or fail to
+ *   open a posix message queue and then reports whether or not they
+ *   did as they were supposed to.
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <mqueue.h>
+
+static char *usage =
+"Usage:\n"
+"  %s path\n"
+"\n"
+"       path    Path name of the message queue to create\n"
+"\n"
+"       Note: this program must be run as root in order to enable all tests\n"
+"\n";
+
+char *DEF_MSGS = "/proc/sys/fs/mqueue/msg_default";
+char *DEF_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_default";
+char *MAX_MSGS = "/proc/sys/fs/mqueue/msg_max";
+char *MAX_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_max";
+
+int default_settings;
+struct rlimit saved_limits, cur_limits;
+int saved_def_msgs, saved_def_msgsize, saved_max_msgs, saved_max_msgsize;
+int cur_def_msgs, cur_def_msgsize, cur_max_msgs, cur_max_msgsize;
+FILE *def_msgs, *def_msgsize, *max_msgs, *max_msgsize;
+char *queue_path;
+mqd_t queue = -1;
+
+static inline void __set(FILE *stream, int value, char *err_msg);
+void shutdown(int exit_val, char *err_cause, int line_no);
+static inline int get(FILE *stream);
+static inline void set(FILE *stream, int value);
+static inline void getr(int type, struct rlimit *rlim);
+static inline void setr(int type, struct rlimit *rlim);
+void validate_current_settings();
+static inline void test_queue(struct mq_attr *attr, struct mq_attr *result);
+static inline int test_queue_fail(struct mq_attr *attr, struct mq_attr *result);
+
+static inline void __set(FILE *stream, int value, char *err_msg)
+{
+        rewind(stream);
+        if (fprintf(stream, "%d", value) < 0)
+                perror(err_msg);
+}
+
+
+void shutdown(int exit_val, char *err_cause, int line_no)
+{
+        static int in_shutdown = 0;
+
+        /* In case we get called recursively by a set() call below */
+        if (in_shutdown++)
+                return;
+
+        seteuid(0);
+
+        if (queue != -1)
+                if (mq_close(queue))
+                        perror("mq_close() during shutdown");
+        if (queue_path)
+                /*
+                 * Be silent if this fails, if we cleaned up already it's
+                 * expected to fail
+                 */
+                mq_unlink(queue_path);
+        if (default_settings) {
+                if (saved_def_msgs)
+                        __set(def_msgs, saved_def_msgs,
+                              "failed to restore saved_def_msgs");
+                if (saved_def_msgsize)
+                        __set(def_msgsize, saved_def_msgsize,
+                              "failed to restore saved_def_msgsize");
+        }
+        if (saved_max_msgs)
+                __set(max_msgs, saved_max_msgs,
+                      "failed to restore saved_max_msgs");
+        if (saved_max_msgsize)
+                __set(max_msgsize, saved_max_msgsize,
+                      "failed to restore saved_max_msgsize");
+        if (exit_val)
+                error(exit_val, errno, "%s at %d", err_cause, line_no);
+        exit(0);
+}
+
+static inline int get(FILE *stream)
+{
+        int value;
+        rewind(stream);
+        if (fscanf(stream, "%d", &value) != 1)
+                shutdown(4, "Error reading /proc entry", __LINE__ - 1);
+        return value;
+}
+
+static inline void set(FILE *stream, int value)
+{
+        int new_value;
+
+        rewind(stream);
+        if (fprintf(stream, "%d", value) < 0)
+                return shutdown(5, "Failed writing to /proc file",
+                                __LINE__ - 1);
+        new_value = get(stream);
+        if (new_value != value)
+                return shutdown(5, "We didn't get what we wrote to /proc back",
+                                __LINE__ - 1);
+}
+
+static inline void getr(int type, struct rlimit *rlim)
+{
+        if (getrlimit(type, rlim))
+                shutdown(6, "getrlimit()", __LINE__ - 1);
+}
+
+static inline void setr(int type, struct rlimit *rlim)
+{
+        if (setrlimit(type, rlim))
+                shutdown(7, "setrlimit()", __LINE__ - 1);
+}
+
+void validate_current_settings()
+{
+        int rlim_needed;
+
+        if (cur_limits.rlim_cur < 4096) {
+                printf("Current rlimit value for POSIX message queue bytes is "
+                       "unreasonably low,\nincreasing.\n\n");
+                cur_limits.rlim_cur = 8192;
+                cur_limits.rlim_max = 16384;
+                setr(RLIMIT_MSGQUEUE, &cur_limits);
+        }
+
+        if (default_settings) {
+                rlim_needed = (cur_def_msgs + 1) * (cur_def_msgsize + 1 +
+                                                    2 * sizeof(void *));
+                if (rlim_needed > cur_limits.rlim_cur) {
+                        printf("Temporarily lowering default queue parameters "
+                               "to something that will work\n"
+                               "with the current rlimit values.\n\n");
+                        set(def_msgs, 10);
+                        cur_def_msgs = 10;
+                        set(def_msgsize, 128);
+                        cur_def_msgsize = 128;
+                }
+        } else {
+                rlim_needed = (cur_max_msgs + 1) * (cur_max_msgsize + 1 +
+                                                    2 * sizeof(void *));
+                if (rlim_needed > cur_limits.rlim_cur) {
+                        printf("Temporarily lowering maximum queue parameters "