Whamcloud - gitweb
LU-5577 libcfs: fix warnings in libcfs/curproc.h
[fs/lustre-release.git] / libcfs / include / libcfs / lucache.h
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2012, Intel Corporation.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  */
36
37 #ifndef _LUCACHE_H
38 #define _LUCACHE_H
39
40 #include <libcfs/libcfs.h>
41 #include <lnet/types.h>
42
43 /** \defgroup ucache ucache
44  *
45  * @{
46  */
47
48 #define UC_CACHE_NEW            0x01
49 #define UC_CACHE_ACQUIRING      0x02
50 #define UC_CACHE_INVALID        0x04
51 #define UC_CACHE_EXPIRED        0x08
52
53 #define UC_CACHE_IS_NEW(i)          ((i)->ue_flags & UC_CACHE_NEW)
54 #define UC_CACHE_IS_INVALID(i)      ((i)->ue_flags & UC_CACHE_INVALID)
55 #define UC_CACHE_IS_ACQUIRING(i)    ((i)->ue_flags & UC_CACHE_ACQUIRING)
56 #define UC_CACHE_IS_EXPIRED(i)      ((i)->ue_flags & UC_CACHE_EXPIRED)
57 #define UC_CACHE_IS_VALID(i)        ((i)->ue_flags == 0)
58
59 #define UC_CACHE_SET_NEW(i)         (i)->ue_flags |= UC_CACHE_NEW
60 #define UC_CACHE_SET_INVALID(i)     (i)->ue_flags |= UC_CACHE_INVALID
61 #define UC_CACHE_SET_ACQUIRING(i)   (i)->ue_flags |= UC_CACHE_ACQUIRING
62 #define UC_CACHE_SET_EXPIRED(i)     (i)->ue_flags |= UC_CACHE_EXPIRED
63 #define UC_CACHE_SET_VALID(i)       (i)->ue_flags = 0
64
65 #define UC_CACHE_CLEAR_NEW(i)       (i)->ue_flags &= ~UC_CACHE_NEW
66 #define UC_CACHE_CLEAR_ACQUIRING(i) (i)->ue_flags &= ~UC_CACHE_ACQUIRING
67 #define UC_CACHE_CLEAR_INVALID(i)   (i)->ue_flags &= ~UC_CACHE_INVALID
68 #define UC_CACHE_CLEAR_EXPIRED(i)   (i)->ue_flags &= ~UC_CACHE_EXPIRED
69
70 struct upcall_cache_entry;
71
72 struct md_perm {
73         lnet_nid_t      mp_nid;
74         __u32           mp_perm;
75 };
76
77 struct md_identity {
78         struct upcall_cache_entry *mi_uc_entry;
79         uid_t                      mi_uid;
80         gid_t                      mi_gid;
81         struct group_info          *mi_ginfo;
82         int                        mi_nperms;
83         struct md_perm            *mi_perms;
84 };
85
86 struct upcall_cache_entry {
87         struct list_head        ue_hash;
88         __u64                   ue_key;
89         atomic_t                ue_refcount;
90         int                     ue_flags;
91         wait_queue_head_t       ue_waitq;
92         cfs_time_t              ue_acquire_expire;
93         cfs_time_t              ue_expire;
94         union {
95                 struct md_identity      identity;
96         } u;
97 };
98
99 #define UC_CACHE_HASH_SIZE        (128)
100 #define UC_CACHE_HASH_INDEX(id)   ((id) & (UC_CACHE_HASH_SIZE - 1))
101 #define UC_CACHE_UPCALL_MAXPATH   (1024UL)
102
103 struct upcall_cache;
104
105 struct upcall_cache_ops {
106         void            (*init_entry)(struct upcall_cache_entry *, void *args);
107         void            (*free_entry)(struct upcall_cache *,
108                                       struct upcall_cache_entry *);
109         int             (*upcall_compare)(struct upcall_cache *,
110                                           struct upcall_cache_entry *,
111                                           __u64 key, void *args);
112         int             (*downcall_compare)(struct upcall_cache *,
113                                             struct upcall_cache_entry *,
114                                             __u64 key, void *args);
115         int             (*do_upcall)(struct upcall_cache *,
116                                      struct upcall_cache_entry *);
117         int             (*parse_downcall)(struct upcall_cache *,
118                                           struct upcall_cache_entry *, void *);
119 };
120
121 struct upcall_cache {
122         struct list_head        uc_hashtable[UC_CACHE_HASH_SIZE];
123         spinlock_t              uc_lock;
124         rwlock_t                uc_upcall_rwlock;
125
126         char                    uc_name[40];            /* for upcall */
127         char                    uc_upcall[UC_CACHE_UPCALL_MAXPATH];
128         int                     uc_acquire_expire;      /* seconds */
129         int                     uc_entry_expire;        /* seconds */
130         struct upcall_cache_ops *uc_ops;
131 };
132
133 struct upcall_cache_entry *upcall_cache_get_entry(struct upcall_cache *cache,
134                                                   __u64 key, void *args);
135 void upcall_cache_put_entry(struct upcall_cache *cache,
136                             struct upcall_cache_entry *entry);
137 int upcall_cache_downcall(struct upcall_cache *cache, __u32 err, __u64 key,
138                           void *args);
139 void upcall_cache_flush_idle(struct upcall_cache *cache);
140 void upcall_cache_flush_all(struct upcall_cache *cache);
141 void upcall_cache_flush_one(struct upcall_cache *cache, __u64 key, void *args);
142 struct upcall_cache *upcall_cache_init(const char *name, const char *upcall,
143                                        struct upcall_cache_ops *ops);
144 void upcall_cache_cleanup(struct upcall_cache *cache);
145
146 #if 0
147 struct upcall_cache_entry *upcall_cache_get_entry(struct upcall_cache *hash,
148                                                   __u64 key, __u32 primary,
149                                                   __u32 ngroups, __u32 *groups);
150 void upcall_cache_put_entry(struct upcall_cache *hash,
151                             struct upcall_cache_entry *entry);
152 int upcall_cache_downcall(struct upcall_cache *hash, __u32 err, __u64 key,
153                           __u32 primary, __u32 ngroups, __u32 *groups);
154 void upcall_cache_flush_idle(struct upcall_cache *cache);
155 void upcall_cache_flush_all(struct upcall_cache *cache);
156 struct upcall_cache *upcall_cache_init(const char *name);
157 void upcall_cache_cleanup(struct upcall_cache *hash);
158
159 #endif
160
161 /** @} ucache */
162
163 #endif /* _LUCACHE_H */