1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
6 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 only,
10 * as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License version 2 for more details (a copy is included
16 * in the LICENSE file that accompanied this code).
18 * You should have received a copy of the GNU General Public License
19 * version 2 along with this program; If not, see
20 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
22 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23 * CA 95054 USA or visit www.sun.com if you need additional information or
29 * Copyright 2008 Sun Microsystems, Inc. All rights reserved
30 * Use is subject to license terms.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
36 * lustre/llite/llite_rmtacl.c
38 * Lustre Remote User Access Control List.
40 * Author: Fan Yong <fanyong@clusterfs.com>
43 #define DEBUG_SUBSYSTEM S_LLITE
45 #ifdef CONFIG_FS_POSIX_ACL
47 #include <lustre_lite.h>
48 #include "llite_internal.h"
50 static inline __u32 rce_hashfunc(uid_t id)
52 return id & (RCE_HASHES - 1);
55 static inline __u32 ee_hashfunc(uid_t id)
57 return id & (EE_HASHES - 1);
60 obd_valid rce_ops2valid(int ops)
64 return OBD_MD_FLRMTLSETFACL;
66 return OBD_MD_FLRMTLGETFACL;
68 return OBD_MD_FLRMTRSETFACL;
70 return OBD_MD_FLRMTRGETFACL;
76 static struct rmtacl_ctl_entry *rce_alloc(pid_t key, int ops)
78 struct rmtacl_ctl_entry *rce;
84 CFS_INIT_LIST_HEAD(&rce->rce_list);
91 static void rce_free(struct rmtacl_ctl_entry *rce)
93 if (!cfs_list_empty(&rce->rce_list))
94 cfs_list_del(&rce->rce_list);
99 static struct rmtacl_ctl_entry *__rct_search(struct rmtacl_ctl_table *rct,
102 struct rmtacl_ctl_entry *rce;
103 cfs_list_t *head = &rct->rct_entries[rce_hashfunc(key)];
105 cfs_list_for_each_entry(rce, head, rce_list)
106 if (rce->rce_key == key)
112 struct rmtacl_ctl_entry *rct_search(struct rmtacl_ctl_table *rct, pid_t key)
114 struct rmtacl_ctl_entry *rce;
116 cfs_spin_lock(&rct->rct_lock);
117 rce = __rct_search(rct, key);
118 cfs_spin_unlock(&rct->rct_lock);
122 int rct_add(struct rmtacl_ctl_table *rct, pid_t key, int ops)
124 struct rmtacl_ctl_entry *rce, *e;
126 rce = rce_alloc(key, ops);
130 cfs_spin_lock(&rct->rct_lock);
131 e = __rct_search(rct, key);
132 if (unlikely(e != NULL)) {
133 CWARN("Unexpected stale rmtacl_entry found: "
134 "[key: %d] [ops: %d]\n", (int)key, ops);
137 cfs_list_add_tail(&rce->rce_list, &rct->rct_entries[rce_hashfunc(key)]);
138 cfs_spin_unlock(&rct->rct_lock);
143 int rct_del(struct rmtacl_ctl_table *rct, pid_t key)
145 struct rmtacl_ctl_entry *rce;
147 cfs_spin_lock(&rct->rct_lock);
148 rce = __rct_search(rct, key);
151 cfs_spin_unlock(&rct->rct_lock);
153 return rce ? 0 : -ENOENT;
156 void rct_init(struct rmtacl_ctl_table *rct)
160 cfs_spin_lock_init(&rct->rct_lock);
161 for (i = 0; i < RCE_HASHES; i++)
162 CFS_INIT_LIST_HEAD(&rct->rct_entries[i]);
165 void rct_fini(struct rmtacl_ctl_table *rct)
167 struct rmtacl_ctl_entry *rce;
170 cfs_spin_lock(&rct->rct_lock);
171 for (i = 0; i < RCE_HASHES; i++)
172 while (!cfs_list_empty(&rct->rct_entries[i])) {
173 rce = cfs_list_entry(rct->rct_entries[i].next,
174 struct rmtacl_ctl_entry, rce_list);
177 cfs_spin_unlock(&rct->rct_lock);
181 static struct eacl_entry *ee_alloc(pid_t key, struct lu_fid *fid, int type,
182 ext_acl_xattr_header *header)
184 struct eacl_entry *ee;
190 CFS_INIT_LIST_HEAD(&ee->ee_list);
199 void ee_free(struct eacl_entry *ee)
201 if (!cfs_list_empty(&ee->ee_list))
202 cfs_list_del(&ee->ee_list);
205 lustre_ext_acl_xattr_free(ee->ee_acl);
210 static struct eacl_entry *__et_search_del(struct eacl_table *et, pid_t key,
211 struct lu_fid *fid, int type)
213 struct eacl_entry *ee;
214 cfs_list_t *head = &et->et_entries[ee_hashfunc(key)];
216 LASSERT(fid != NULL);
217 cfs_list_for_each_entry(ee, head, ee_list)
218 if (ee->ee_key == key) {
219 if (lu_fid_eq(&ee->ee_fid, fid) &&
220 ee->ee_type == type) {
221 cfs_list_del_init(&ee->ee_list);
229 struct eacl_entry *et_search_del(struct eacl_table *et, pid_t key,
230 struct lu_fid *fid, int type)
232 struct eacl_entry *ee;
234 cfs_spin_lock(&et->et_lock);
235 ee = __et_search_del(et, key, fid, type);
236 cfs_spin_unlock(&et->et_lock);
240 void et_search_free(struct eacl_table *et, pid_t key)
242 struct eacl_entry *ee, *next;
243 cfs_list_t *head = &et->et_entries[ee_hashfunc(key)];
245 cfs_spin_lock(&et->et_lock);
246 cfs_list_for_each_entry_safe(ee, next, head, ee_list)
247 if (ee->ee_key == key)
250 cfs_spin_unlock(&et->et_lock);
253 int ee_add(struct eacl_table *et, pid_t key, struct lu_fid *fid, int type,
254 ext_acl_xattr_header *header)
256 struct eacl_entry *ee, *e;
258 ee = ee_alloc(key, fid, type, header);
262 cfs_spin_lock(&et->et_lock);
263 e = __et_search_del(et, key, fid, type);
264 if (unlikely(e != NULL)) {
265 CWARN("Unexpected stale eacl_entry found: "
266 "[key: %d] [fid: "DFID"] [type: %d]\n",
267 (int)key, PFID(fid), type);
270 cfs_list_add_tail(&ee->ee_list, &et->et_entries[ee_hashfunc(key)]);
271 cfs_spin_unlock(&et->et_lock);
276 void et_init(struct eacl_table *et)
280 cfs_spin_lock_init(&et->et_lock);
281 for (i = 0; i < EE_HASHES; i++)
282 CFS_INIT_LIST_HEAD(&et->et_entries[i]);
285 void et_fini(struct eacl_table *et)
287 struct eacl_entry *ee;
290 cfs_spin_lock(&et->et_lock);
291 for (i = 0; i < EE_HASHES; i++)
292 while (!cfs_list_empty(&et->et_entries[i])) {
293 ee = cfs_list_entry(et->et_entries[i].next,
294 struct eacl_entry, ee_list);
297 cfs_spin_unlock(&et->et_lock);