X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fllite%2Fllite_rmtacl.c;h=4f22a20b42b2dbbaaa836fe61538c91cb1b979d2;hb=c5fa6f85b6bceef574a52752eefc4847d1b571f5;hp=d9869fd9f74db3ab76744d4b3760f8aac0a44931;hpb=0f8dca08a4f68cba82c2c822998ecc309d3b7aaf;p=fs%2Flustre-release.git diff --git a/lustre/llite/llite_rmtacl.c b/lustre/llite/llite_rmtacl.c index d9869fd..4f22a20 100644 --- a/lustre/llite/llite_rmtacl.c +++ b/lustre/llite/llite_rmtacl.c @@ -1,6 +1,4 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * GPL HEADER START * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. @@ -28,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/ @@ -45,6 +45,7 @@ #ifdef CONFIG_FS_POSIX_ACL #include +#include #include "llite_internal.h" static inline __u32 rce_hashfunc(uid_t id) @@ -81,7 +82,7 @@ static struct rmtacl_ctl_entry *rce_alloc(pid_t key, int ops) if (!rce) return NULL; - CFS_INIT_LIST_HEAD(&rce->rce_list); + INIT_LIST_HEAD(&rce->rce_list); rce->rce_key = key; rce->rce_ops = ops; @@ -90,8 +91,8 @@ static struct rmtacl_ctl_entry *rce_alloc(pid_t key, int ops) static void rce_free(struct rmtacl_ctl_entry *rce) { - if (!cfs_list_empty(&rce->rce_list)) - cfs_list_del(&rce->rce_list); + if (!list_empty(&rce->rce_list)) + list_del(&rce->rce_list); OBD_FREE_PTR(rce); } @@ -100,9 +101,9 @@ static struct rmtacl_ctl_entry *__rct_search(struct rmtacl_ctl_table *rct, pid_t key) { struct rmtacl_ctl_entry *rce; - cfs_list_t *head = &rct->rct_entries[rce_hashfunc(key)]; + struct list_head *head = &rct->rct_entries[rce_hashfunc(key)]; - cfs_list_for_each_entry(rce, head, rce_list) + list_for_each_entry(rce, head, rce_list) if (rce->rce_key == key) return rce; @@ -111,12 +112,12 @@ static struct rmtacl_ctl_entry *__rct_search(struct rmtacl_ctl_table *rct, struct rmtacl_ctl_entry *rct_search(struct rmtacl_ctl_table *rct, pid_t key) { - struct rmtacl_ctl_entry *rce; + struct rmtacl_ctl_entry *rce; - cfs_spin_lock(&rct->rct_lock); - rce = __rct_search(rct, key); - cfs_spin_unlock(&rct->rct_lock); - return rce; + spin_lock(&rct->rct_lock); + rce = __rct_search(rct, key); + spin_unlock(&rct->rct_lock); + return rce; } int rct_add(struct rmtacl_ctl_table *rct, pid_t key, int ops) @@ -127,54 +128,54 @@ int rct_add(struct rmtacl_ctl_table *rct, pid_t key, int ops) if (rce == NULL) return -ENOMEM; - cfs_spin_lock(&rct->rct_lock); - e = __rct_search(rct, key); - if (unlikely(e != NULL)) { - CWARN("Unexpected stale rmtacl_entry found: " - "[key: %d] [ops: %d]\n", (int)key, ops); - rce_free(e); - } - cfs_list_add_tail(&rce->rce_list, &rct->rct_entries[rce_hashfunc(key)]); - cfs_spin_unlock(&rct->rct_lock); - - return 0; + spin_lock(&rct->rct_lock); + e = __rct_search(rct, key); + if (unlikely(e != NULL)) { + CWARN("Unexpected stale rmtacl_entry found: " + "[key: %d] [ops: %d]\n", (int)key, ops); + rce_free(e); + } + list_add_tail(&rce->rce_list, &rct->rct_entries[rce_hashfunc(key)]); + spin_unlock(&rct->rct_lock); + + return 0; } int rct_del(struct rmtacl_ctl_table *rct, pid_t key) { - struct rmtacl_ctl_entry *rce; + struct rmtacl_ctl_entry *rce; - cfs_spin_lock(&rct->rct_lock); - rce = __rct_search(rct, key); - if (rce) - rce_free(rce); - cfs_spin_unlock(&rct->rct_lock); + spin_lock(&rct->rct_lock); + rce = __rct_search(rct, key); + if (rce) + rce_free(rce); + spin_unlock(&rct->rct_lock); - return rce ? 0 : -ENOENT; + return rce ? 0 : -ENOENT; } void rct_init(struct rmtacl_ctl_table *rct) { - int i; + int i; - cfs_spin_lock_init(&rct->rct_lock); - for (i = 0; i < RCE_HASHES; i++) - CFS_INIT_LIST_HEAD(&rct->rct_entries[i]); + spin_lock_init(&rct->rct_lock); + for (i = 0; i < RCE_HASHES; i++) + INIT_LIST_HEAD(&rct->rct_entries[i]); } void rct_fini(struct rmtacl_ctl_table *rct) { - struct rmtacl_ctl_entry *rce; - int i; - - cfs_spin_lock(&rct->rct_lock); - for (i = 0; i < RCE_HASHES; i++) - while (!cfs_list_empty(&rct->rct_entries[i])) { - rce = cfs_list_entry(rct->rct_entries[i].next, - struct rmtacl_ctl_entry, rce_list); - rce_free(rce); - } - cfs_spin_unlock(&rct->rct_lock); + struct rmtacl_ctl_entry *rce; + int i; + + spin_lock(&rct->rct_lock); + for (i = 0; i < RCE_HASHES; i++) + while (!list_empty(&rct->rct_entries[i])) { + rce = list_entry(rct->rct_entries[i].next, + struct rmtacl_ctl_entry, rce_list); + rce_free(rce); + } + spin_unlock(&rct->rct_lock); } @@ -187,7 +188,7 @@ static struct eacl_entry *ee_alloc(pid_t key, struct lu_fid *fid, int type, if (!ee) return NULL; - CFS_INIT_LIST_HEAD(&ee->ee_list); + INIT_LIST_HEAD(&ee->ee_list); ee->ee_key = key; ee->ee_fid = *fid; ee->ee_type = type; @@ -198,8 +199,8 @@ static struct eacl_entry *ee_alloc(pid_t key, struct lu_fid *fid, int type, void ee_free(struct eacl_entry *ee) { - if (!cfs_list_empty(&ee->ee_list)) - cfs_list_del(&ee->ee_list); + if (!list_empty(&ee->ee_list)) + list_del(&ee->ee_list); if (ee->ee_acl) lustre_ext_acl_xattr_free(ee->ee_acl); @@ -211,14 +212,14 @@ static struct eacl_entry *__et_search_del(struct eacl_table *et, pid_t key, struct lu_fid *fid, int type) { struct eacl_entry *ee; - cfs_list_t *head = &et->et_entries[ee_hashfunc(key)]; + struct list_head *head = &et->et_entries[ee_hashfunc(key)]; LASSERT(fid != NULL); - cfs_list_for_each_entry(ee, head, ee_list) + list_for_each_entry(ee, head, ee_list) if (ee->ee_key == key) { if (lu_fid_eq(&ee->ee_fid, fid) && ee->ee_type == type) { - cfs_list_del_init(&ee->ee_list); + list_del_init(&ee->ee_list); return ee; } } @@ -229,25 +230,25 @@ static struct eacl_entry *__et_search_del(struct eacl_table *et, pid_t key, struct eacl_entry *et_search_del(struct eacl_table *et, pid_t key, struct lu_fid *fid, int type) { - struct eacl_entry *ee; + struct eacl_entry *ee; - cfs_spin_lock(&et->et_lock); - ee = __et_search_del(et, key, fid, type); - cfs_spin_unlock(&et->et_lock); - return ee; + spin_lock(&et->et_lock); + ee = __et_search_del(et, key, fid, type); + spin_unlock(&et->et_lock); + return ee; } void et_search_free(struct eacl_table *et, pid_t key) { - struct eacl_entry *ee, *next; - cfs_list_t *head = &et->et_entries[ee_hashfunc(key)]; + struct eacl_entry *ee, *next; + struct list_head *head = &et->et_entries[ee_hashfunc(key)]; - cfs_spin_lock(&et->et_lock); - cfs_list_for_each_entry_safe(ee, next, head, ee_list) - if (ee->ee_key == key) - ee_free(ee); + spin_lock(&et->et_lock); + list_for_each_entry_safe(ee, next, head, ee_list) + if (ee->ee_key == key) + ee_free(ee); - cfs_spin_unlock(&et->et_lock); + spin_unlock(&et->et_lock); } int ee_add(struct eacl_table *et, pid_t key, struct lu_fid *fid, int type, @@ -259,42 +260,42 @@ int ee_add(struct eacl_table *et, pid_t key, struct lu_fid *fid, int type, if (ee == NULL) return -ENOMEM; - cfs_spin_lock(&et->et_lock); - e = __et_search_del(et, key, fid, type); - if (unlikely(e != NULL)) { - CWARN("Unexpected stale eacl_entry found: " - "[key: %d] [fid: "DFID"] [type: %d]\n", - (int)key, PFID(fid), type); - ee_free(e); - } - cfs_list_add_tail(&ee->ee_list, &et->et_entries[ee_hashfunc(key)]); - cfs_spin_unlock(&et->et_lock); - - return 0; + spin_lock(&et->et_lock); + e = __et_search_del(et, key, fid, type); + if (unlikely(e != NULL)) { + CWARN("Unexpected stale eacl_entry found: " + "[key: %d] [fid: "DFID"] [type: %d]\n", + (int)key, PFID(fid), type); + ee_free(e); + } + list_add_tail(&ee->ee_list, &et->et_entries[ee_hashfunc(key)]); + spin_unlock(&et->et_lock); + + return 0; } void et_init(struct eacl_table *et) { - int i; + int i; - cfs_spin_lock_init(&et->et_lock); - for (i = 0; i < EE_HASHES; i++) - CFS_INIT_LIST_HEAD(&et->et_entries[i]); + spin_lock_init(&et->et_lock); + for (i = 0; i < EE_HASHES; i++) + INIT_LIST_HEAD(&et->et_entries[i]); } void et_fini(struct eacl_table *et) { - struct eacl_entry *ee; - int i; - - cfs_spin_lock(&et->et_lock); - for (i = 0; i < EE_HASHES; i++) - while (!cfs_list_empty(&et->et_entries[i])) { - ee = cfs_list_entry(et->et_entries[i].next, - struct eacl_entry, ee_list); - ee_free(ee); - } - cfs_spin_unlock(&et->et_lock); + struct eacl_entry *ee; + int i; + + spin_lock(&et->et_lock); + for (i = 0; i < EE_HASHES; i++) + while (!list_empty(&et->et_entries[i])) { + ee = list_entry(et->et_entries[i].next, + struct eacl_entry, ee_list); + ee_free(ee); + } + spin_unlock(&et->et_lock); } #endif