Whamcloud - gitweb
LU-4528 llog: don't write llog in 3-steps
[fs/lustre-release.git] / lustre / obdclass / idmap.c
index 605c039..146b40e 100644 (file)
@@ -26,6 +26,8 @@
 /*
  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
+ *
+ * Copyright (c) 2012, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
 
 #define DEBUG_SUBSYSTEM S_SEC
 
+#include <libcfs/lucache.h>
+
 #include <lustre_idmap.h>
+#include <md_object.h>
 #include <obd_support.h>
 
 #define lustre_get_group_info(group_info) do {             \
-        cfs_atomic_inc(&(group_info)->usage);              \
+       atomic_inc(&(group_info)->usage);              \
 } while (0)
 
 #define lustre_put_group_info(group_info) do {             \
-        if (cfs_atomic_dec_and_test(&(group_info)->usage)) \
-                cfs_groups_free(group_info);               \
+       if (atomic_dec_and_test(&(group_info)->usage)) \
+               groups_free(group_info);                   \
 } while (0)
 
 /*
  * groups_search() is copied from linux kernel!
  * A simple bsearch.
  */
-static int lustre_groups_search(cfs_group_info_t *group_info,
-                                gid_t grp)
+static int lustre_groups_search(struct group_info *group_info,
+                               gid_t grp)
 {
-        int left, right;
-
-        if (!group_info)
-                return 0;
-
-        left = 0;
-        right = group_info->ngroups;
-        while (left < right) {
-                int mid = (left + right) / 2;
-                int cmp = grp - CFS_GROUP_AT(group_info, mid);
-
-                if (cmp > 0)
-                        left = mid + 1;
-                else if (cmp < 0)
-                        right = mid;
-                else
-                        return 1;
-        }
-        return 0;
+       int left, right;
+
+       if (!group_info)
+               return 0;
+
+       left = 0;
+       right = group_info->ngroups;
+       while (left < right) {
+               int mid = (left + right) / 2;
+               int cmp = grp -
+                       from_kgid(&init_user_ns, CFS_GROUP_AT(group_info, mid));
+
+               if (cmp > 0)
+                       left = mid + 1;
+               else if (cmp < 0)
+                       right = mid;
+               else
+                       return 1;
+       }
+       return 0;
 }
 
-void lustre_groups_from_list(cfs_group_info_t *ginfo, gid_t *glist)
+void lustre_groups_from_list(struct group_info *ginfo, gid_t *glist)
 {
-        int i;
-        int count = ginfo->ngroups;
-
-        /* fill group_info from gid array */
-        for (i = 0; i < ginfo->nblocks && count > 0; i++) {
-                int cp_count = min(CFS_NGROUPS_PER_BLOCK, count);
-                int off = i * CFS_NGROUPS_PER_BLOCK;
-                int len = cp_count * sizeof(*glist);
-
-                memcpy(ginfo->blocks[i], glist + off, len);
-                count -= cp_count;
-        }
+       int i;
+       int count = ginfo->ngroups;
+
+       /* fill group_info from gid array */
+       for (i = 0; i < ginfo->nblocks && count > 0; i++) {
+               int cp_count = min(CFS_NGROUPS_PER_BLOCK, count);
+               int off = i * CFS_NGROUPS_PER_BLOCK;
+               int len = cp_count * sizeof(*glist);
+
+               memcpy(ginfo->blocks[i], glist + off, len);
+               count -= cp_count;
+       }
 }
 EXPORT_SYMBOL(lustre_groups_from_list);
 
 /* groups_sort() is copied from linux kernel! */
 /* a simple shell-metzner sort */
-void lustre_groups_sort(cfs_group_info_t *group_info)
+void lustre_groups_sort(struct group_info *group_info)
 {
         int base, max, stride;
         int gidsetsize = group_info->ngroups;
@@ -108,53 +114,56 @@ void lustre_groups_sort(cfs_group_info_t *group_info)
                 ; /* nothing */
         stride /= 3;
 
-        while (stride) {
-                max = gidsetsize - stride;
-                for (base = 0; base < max; base++) {
-                        int left = base;
-                        int right = left + stride;
-                        gid_t tmp = CFS_GROUP_AT(group_info, right);
-
-                        while (left >= 0 &&
-                               CFS_GROUP_AT(group_info, left) > tmp) {
-                                CFS_GROUP_AT(group_info, right) =
-                                    CFS_GROUP_AT(group_info, left);
-                                right = left;
-                                left -= stride;
-                        }
-                        CFS_GROUP_AT(group_info, right) = tmp;
-                }
-                stride /= 3;
-        }
+       while (stride) {
+               max = gidsetsize - stride;
+               for (base = 0; base < max; base++) {
+                       int left = base;
+                       int right = left + stride;
+                       gid_t tmp = from_kgid(&init_user_ns,
+                                             CFS_GROUP_AT(group_info, right));
+
+                       while (left >= 0 &&
+                              tmp < from_kgid(&init_user_ns,
+                                              CFS_GROUP_AT(group_info, left))) {
+                               CFS_GROUP_AT(group_info, right) =
+                                       CFS_GROUP_AT(group_info, left);
+                               right = left;
+                               left -= stride;
+                       }
+                       CFS_GROUP_AT(group_info, right) =
+                                               make_kgid(&init_user_ns, tmp);
+               }
+               stride /= 3;
+       }
 }
 EXPORT_SYMBOL(lustre_groups_sort);
 
-int lustre_in_group_p(struct md_ucred *mu, gid_t grp)
+int lustre_in_group_p(struct lu_ucred *mu, gid_t grp)
 {
-        int rc = 1;
+       int rc = 1;
 
-        if (grp != mu->mu_fsgid) {
-                cfs_group_info_t *group_info = NULL;
+       if (grp != mu->uc_fsgid) {
+               struct group_info *group_info = NULL;
 
-                if (mu->mu_ginfo || !mu->mu_identity ||
-                    mu->mu_valid == UCRED_OLD)
-                        if (grp == mu->mu_suppgids[0] ||
-                            grp == mu->mu_suppgids[1])
-                                return 1;
+               if (mu->uc_ginfo || !mu->uc_identity ||
+                   mu->uc_valid == UCRED_OLD)
+                       if (grp == mu->uc_suppgids[0] ||
+                           grp == mu->uc_suppgids[1])
+                               return 1;
 
-                if (mu->mu_ginfo)
-                        group_info = mu->mu_ginfo;
-                else if (mu->mu_identity)
-                        group_info = mu->mu_identity->mi_ginfo;
+               if (mu->uc_ginfo)
+                       group_info = mu->uc_ginfo;
+               else if (mu->uc_identity)
+                       group_info = mu->uc_identity->mi_ginfo;
 
-                if (!group_info)
-                        return 0;
+               if (!group_info)
+                       return 0;
 
-                lustre_get_group_info(group_info);
-                rc = lustre_groups_search(group_info, grp);
-                lustre_put_group_info(group_info);
-        }
-        return rc;
+               lustre_get_group_info(group_info);
+               rc = lustre_groups_search(group_info, grp);
+               lustre_put_group_info(group_info);
+       }
+       return rc;
 }
 EXPORT_SYMBOL(lustre_in_group_p);
 
@@ -365,25 +374,25 @@ int lustre_idmap_del(struct lustre_idmap_table *t,
 }
 EXPORT_SYMBOL(lustre_idmap_del);
 
-int lustre_idmap_lookup_uid(struct md_ucred *mu,
-                            struct lustre_idmap_table *t,
-                            int reverse, uid_t uid)
+int lustre_idmap_lookup_uid(struct lu_ucred *mu,
+                           struct lustre_idmap_table *t,
+                           int reverse, uid_t uid)
 {
-        cfs_list_t *hash;
-
-        if (mu && (mu->mu_valid == UCRED_OLD || mu->mu_valid == UCRED_NEW)) {
-                if (!reverse) {
-                        if (uid == mu->mu_o_uid)
-                                return mu->mu_uid;
-                        else if (uid == mu->mu_o_fsuid)
-                                return mu->mu_fsuid;
-                } else {
-                        if (uid == mu->mu_uid)
-                                return mu->mu_o_uid;
-                        else if (uid == mu->mu_fsuid)
-                                return mu->mu_o_fsuid;
-                }
-        }
+       cfs_list_t *hash;
+
+       if (mu && (mu->uc_valid == UCRED_OLD || mu->uc_valid == UCRED_NEW)) {
+               if (!reverse) {
+                       if (uid == mu->uc_o_uid)
+                               return mu->uc_uid;
+                       else if (uid == mu->uc_o_fsuid)
+                               return mu->uc_fsuid;
+               } else {
+                       if (uid == mu->uc_uid)
+                               return mu->uc_o_uid;
+                       else if (uid == mu->uc_fsuid)
+                               return mu->uc_o_fsuid;
+               }
+       }
 
         if (t == NULL)
                 return CFS_IDMAP_NOTFOUND;
@@ -398,24 +407,24 @@ int lustre_idmap_lookup_uid(struct md_ucred *mu,
 }
 EXPORT_SYMBOL(lustre_idmap_lookup_uid);
 
-int lustre_idmap_lookup_gid(struct md_ucred *mu, struct lustre_idmap_table *t,
-                            int reverse, gid_t gid)
+int lustre_idmap_lookup_gid(struct lu_ucred *mu, struct lustre_idmap_table *t,
+                           int reverse, gid_t gid)
 {
-        cfs_list_t *hash;
-
-        if (mu && (mu->mu_valid == UCRED_OLD || mu->mu_valid == UCRED_NEW)) {
-                if (!reverse) {
-                        if (gid == mu->mu_o_gid)
-                                return mu->mu_gid;
-                        else if (gid == mu->mu_o_fsgid)
-                                return mu->mu_fsgid;
-                } else {
-                        if (gid == mu->mu_gid)
-                                return mu->mu_o_gid;
-                        else if (gid == mu->mu_fsgid)
-                                return mu->mu_o_fsgid;
-                }
-        }
+       cfs_list_t *hash;
+
+       if (mu && (mu->uc_valid == UCRED_OLD || mu->uc_valid == UCRED_NEW)) {
+               if (!reverse) {
+                       if (gid == mu->uc_o_gid)
+                               return mu->uc_gid;
+                       else if (gid == mu->uc_o_fsgid)
+                               return mu->uc_fsgid;
+               } else {
+                       if (gid == mu->uc_gid)
+                               return mu->uc_o_gid;
+                       else if (gid == mu->uc_fsgid)
+                               return mu->uc_o_fsgid;
+               }
+       }
 
         if (t == NULL)
                 return CFS_IDMAP_NOTFOUND;