Linux 4.4: key_payload has no member 'value'

[openafs.git] / src / afs / LINUX / osi_groups.c

diff --git a/src/afs/LINUX/osi_groups.c b/src/afs/LINUX/osi_groups.c
index 1903a54..a83bcb9 100644 (file)
--- a/src/afs/LINUX/osi_groups.c
+++ b/src/afs/LINUX/osi_groups.c
@@ -37,8 +37,8 @@ afs_linux_pag_from_groups(struct group_info *group_info) {
     if (group_info->ngroups < NUMPAGGROUPS)
        return NOPAG;
 
-    for (i = 0; (i < group_info->ngroups &&
-                (g0 = GROUP_AT(group_info, i)) != (gid_t) NOGROUP); i++) {
+    for (i = 0; i < group_info->ngroups; i++) {
+       g0 = afs_from_kgid(GROUP_AT(group_info, i));
        if (((g0 >> 24) & 0xff) == 'A')
            return g0;
     }
@@ -51,6 +51,7 @@ afs_linux_pag_to_groups(afs_uint32 newpag,
     int need_space = 0;
     int i;
     int j;
+    afs_kgid_t newkgid = afs_make_kgid(newpag);
 
     if (afs_linux_pag_from_groups(old) == NOPAG)
        need_space = NUMPAGGROUPS;
@@ -58,19 +59,19 @@ afs_linux_pag_to_groups(afs_uint32 newpag,
     *new = groups_alloc(old->ngroups + need_space);
 
     for (i = 0, j = 0; i < old->ngroups; ++i) {
-       int ths = GROUP_AT(old, i);
-       int last = i > 0 ? GROUP_AT(old, i-1) : 0;
-       if ((ths >> 24) == 'A')
+       afs_kgid_t ths = GROUP_AT(old, i);
+       if ((afs_from_kgid(ths) >> 24) == 'A')
            continue;
-       if (last <= newpag && ths > newpag) {
-          GROUP_AT(*new, j) = newpag;
+       if ((i == 0 || !gid_lt(newkgid, GROUP_AT(old, i-1))) &&
+           gid_lt(newkgid, ths)) {
+          GROUP_AT(*new, j) = newkgid;
           j++;
        }
        GROUP_AT(*new, j) = ths;
        j++;
     }
     if (j != i + need_space)
-        GROUP_AT(*new, j) = newpag;
+        GROUP_AT(*new, j) = newkgid;
 }
 
 #else
@@ -190,7 +191,7 @@ install_session_keyring(struct key *keyring)
        /* if we're root, don't count the keyring against our quota. This
         * avoids starvation issues when dealing with PAM modules that always
         * setpag() as root */
-       if (current_uid() == 0)
+       if (capable(CAP_SYS_ADMIN))
            flags = KEY_ALLOC_NOT_IN_QUOTA;
        else
            flags = KEY_ALLOC_IN_QUOTA;
@@ -214,14 +215,9 @@ install_session_keyring(struct key *keyring)
     }
 
     /* install the keyring */
-    spin_lock_irq(&current->sighand->siglock);
-    old = task_session_keyring(current);
-    smp_wmb();
-    task_session_keyring(current) = keyring;
-    spin_unlock_irq(&current->sighand->siglock);
-
+    old = afs_set_session_keyring(keyring);
     if (old)
-           key_put(old);
+       key_put(old);
 
 out:
     return code;
@@ -255,10 +251,10 @@ setpag(cred_t **cr, afs_uint32 pagvalue, afs_uint32 *newpag,
            perm = KEY_POS_VIEW | KEY_POS_SEARCH;
            perm |= KEY_USR_VIEW | KEY_USR_SEARCH;
 
-           key = afs_linux_key_alloc(&key_type_afs_pag, "_pag", 0, 0, perm, KEY_ALLOC_NOT_IN_QUOTA);
+           key = afs_linux_key_alloc(&key_type_afs_pag, "_pag", GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, perm, KEY_ALLOC_NOT_IN_QUOTA);
 
            if (!IS_ERR(key)) {
-               key_instantiate_and_link(key, (void *) newpag, sizeof(afs_uint32),
+               code = key_instantiate_and_link(key, (void *) newpag, sizeof(afs_uint32),
                                         current_session_keyring(), NULL);
                key_put(key);
            } else {
@@ -457,18 +453,26 @@ static void afs_pag_describe(const struct key *key, struct seq_file *m)
     seq_printf(m, ": %u", key->datalen);
 }
 
+#if defined(STRUCT_KEY_TYPE_HAS_PREPARSE)
+static int afs_pag_instantiate(struct key *key, struct key_preparsed_payload *prep)
+#else
 static int afs_pag_instantiate(struct key *key, const void *data, size_t datalen)
+#endif
 {
     int code;
     afs_uint32 *userpag, pag = NOPAG;
 
-    if (key->uid != 0 || key->gid != 0)
+    if (!uid_eq(key->uid, GLOBAL_ROOT_UID) || !gid_eq(key->gid, GLOBAL_ROOT_GID))
        return -EPERM;
 
     code = -EINVAL;
     get_group_info(current_group_info());
 
+#if defined(STRUCT_KEY_TYPE_HAS_PREPARSE)
+    if (prep->datalen != sizeof(afs_uint32) || !prep->data)
+#else
     if (datalen != sizeof(afs_uint32) || !data)
+#endif
        goto error;
 
     /* ensure key being set matches current pag */
@@ -477,11 +481,19 @@ static int afs_pag_instantiate(struct key *key, const void *data, size_t datalen
     if (pag == NOPAG)
        goto error;
 
-    userpag = (afs_uint32 *) data;
+#if defined(STRUCT_KEY_TYPE_HAS_PREPARSE)
+    userpag = (afs_uint32 *)prep->data;
+#else
+    userpag = (afs_uint32 *)data;
+#endif
     if (*userpag != pag)
        goto error;
 
+#if defined(STRUCT_KEY_HAS_PAYLOAD_VALUE)
     key->payload.value = (unsigned long) *userpag;
+#else
+    memcpy(&key->payload, userpag, sizeof(afs_uint32));
+#endif
     key->datalen = sizeof(afs_uint32);
     code = 0;
 
@@ -490,16 +502,30 @@ error:
     return code;
 }
 
+#if !defined(STRUCT_KEY_TYPE_HAS_MATCH_PREPARSE)
+/* Note that we only define a ->match function if struct
+ * key_type.match_preparse does _not_ exist. If key_type.match_preparse does
+ * exist, we would use that to specify an alternative comparison function; but
+ * since we just rely on default behavior, we don't need to actually specify
+ * one. But for kernels with no such match_preparse function, we need to
+ * specify a 'match' function, since there is no default. */
 static int afs_pag_match(const struct key *key, const void *description)
 {
        return strcmp(key->description, description) == 0;
 }
+#endif
 
 static void afs_pag_destroy(struct key *key)
 {
-    afs_uint32 pag = key->payload.value;
+    afs_uint32 pag;
     int locked = ISAFS_GLOCK();
 
+#if defined(STRUCT_KEY_HAS_PAYLOAD_VALUE)
+    pag = key->payload.value;
+#else
+    memcpy(&pag, &key->payload, sizeof(afs_uint32));
+#endif
+
     if (!locked)
        AFS_GLOCK();
 
@@ -513,8 +539,15 @@ struct key_type key_type_afs_pag =
 {
     .name        = "afs_pag",
     .describe    = afs_pag_describe,
+#if defined(STRUCT_KEY_TYPE_HAS_INSTANTIATE_PREP)
+    .instantiate_prep = afs_pag_instantiate,
+    .instantiate = NULL,
+#else
     .instantiate = afs_pag_instantiate,
+#endif
+#if !defined(STRUCT_KEY_TYPE_HAS_MATCH_PREPARSE)
     .match       = afs_pag_match,
+#endif
     .destroy     = afs_pag_destroy,
 };
 
@@ -585,8 +618,12 @@ osi_get_keyring_pag(afs_ucred_t *cred)
        key = afs_linux_search_keyring(cred, &key_type_afs_pag);
 
        if (!IS_ERR(key)) {
-           if (key_validate(key) == 0 && key->uid == 0) {      /* also verify in the session keyring? */
+           if (key_validate(key) == 0 && uid_eq(key->uid, GLOBAL_ROOT_UID)) {      /* also verify in the session keyring? */
+#if defined(STRUCT_KEY_HAS_PAYLOAD_VALUE)
                keyring_pag = key->payload.value;
+#else
+               memcpy(&keyring_pag, &key->payload, sizeof(afs_int32));
+#endif
                /* Only set PAG in groups if needed,
                 * and the creds are from the current process */
                if (afs_linux_cred_is_current(cred) &&