Whamcloud - gitweb
3561f8e1915cdf6ceab58a1d1222d572bdc05f0a
[fs/lustre-release.git] / lustre / include / lustre_capa.h
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
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.
11  *
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).
17  *
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
21  *
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
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
30  * Use is subject to license terms.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * lustre/include/lustre_capa.h
37  *
38  * Author: Lai Siyao <lsy@clusterfs.com>
39  */
40
41 #ifndef __LINUX_CAPA_H_
42 #define __LINUX_CAPA_H_
43
44 /*
45  * capability
46  */
47 #ifdef __KERNEL__
48 #include <linux/crypto.h>
49 #endif
50 #include <lustre/lustre_idl.h>
51
52 #define CAPA_TIMEOUT 1800                /* sec, == 30 min */
53 #define CAPA_KEY_TIMEOUT (24 * 60 * 60)  /* sec, == 1 days */
54
55 struct capa_hmac_alg {
56         const char     *ha_name;
57         int             ha_len;
58         int             ha_keylen;
59 };
60
61 #define DEF_CAPA_HMAC_ALG(name, type, len, keylen)      \
62 [CAPA_HMAC_ALG_ ## type] = {                            \
63         .ha_name         = name,                        \
64         .ha_len          = len,                         \
65         .ha_keylen       = keylen,                      \
66 }
67
68 struct client_capa {
69         struct inode             *inode;
70         cfs_list_t                lli_list;     /* link to lli_oss_capas */
71 };
72
73 struct target_capa {
74         cfs_hlist_node_t          c_hash;       /* link to capa hash */
75 };
76
77 struct obd_capa {
78         cfs_list_t                c_list;       /* link to capa_list */
79
80         struct lustre_capa        c_capa;       /* capa */
81         cfs_atomic_t              c_refc;       /* ref count */
82         cfs_time_t                c_expiry;     /* jiffies */
83         cfs_spinlock_t            c_lock;       /* protect capa content */
84         int                       c_site;
85
86         union {
87                 struct client_capa      cli;
88                 struct target_capa      tgt;
89         } u;
90 };
91
92 enum {
93         CAPA_SITE_CLIENT = 0,
94         CAPA_SITE_SERVER,
95         CAPA_SITE_MAX
96 };
97
98 static inline struct lu_fid *capa_fid(struct lustre_capa *capa)
99 {
100         return &capa->lc_fid;
101 }
102
103 static inline __u64 capa_opc(struct lustre_capa *capa)
104 {
105         return capa->lc_opc;
106 }
107
108 static inline __u64 capa_uid(struct lustre_capa *capa)
109 {
110         return capa->lc_uid;
111 }
112
113 static inline __u64 capa_gid(struct lustre_capa *capa)
114 {
115         return capa->lc_gid;
116 }
117
118 static inline __u32 capa_flags(struct lustre_capa *capa)
119 {
120         return capa->lc_flags & 0xffffff;
121 }
122
123 static inline __u32 capa_alg(struct lustre_capa *capa)
124 {
125         return (capa->lc_flags >> 24);
126 }
127
128 static inline __u32 capa_keyid(struct lustre_capa *capa)
129 {
130         return capa->lc_keyid;
131 }
132
133 static inline __u64 capa_key_mdsid(struct lustre_capa_key *key)
134 {
135         return key->lk_mdsid;
136 }
137
138 static inline __u32 capa_key_keyid(struct lustre_capa_key *key)
139 {
140         return key->lk_keyid;
141 }
142
143 static inline __u32 capa_timeout(struct lustre_capa *capa)
144 {
145         return capa->lc_timeout;
146 }
147
148 static inline __u32 capa_expiry(struct lustre_capa *capa)
149 {
150         return capa->lc_expiry;
151 }
152
153 #define DEBUG_CAPA(level, c, fmt, args...)                                     \
154 do {                                                                           \
155 CDEBUG(level, fmt " capability@%p fid "DFID" opc "LPX64" uid "LPU64" gid "     \
156        LPU64" flags %u alg %d keyid %u timeout %u expiry %u\n",                \
157        ##args, c, PFID(capa_fid(c)), capa_opc(c), capa_uid(c), capa_gid(c),    \
158        capa_flags(c), capa_alg(c), capa_keyid(c), capa_timeout(c),             \
159        capa_expiry(c));                                                        \
160 } while (0)
161
162 #define DEBUG_CAPA_KEY(level, k, fmt, args...)                                 \
163 do {                                                                           \
164 CDEBUG(level, fmt " capability key@%p mdsid "LPU64" keyid %u\n",               \
165        ##args, k, capa_key_mdsid(k), capa_key_keyid(k));                       \
166 } while (0)
167
168 typedef int (* renew_capa_cb_t)(struct obd_capa *, struct lustre_capa *);
169
170 /* obdclass/capa.c */
171 extern cfs_list_t capa_list[];
172 extern cfs_spinlock_t capa_lock;
173 extern int capa_count[];
174 extern cfs_mem_cache_t *capa_cachep;
175
176 cfs_hlist_head_t *init_capa_hash(void);
177 void cleanup_capa_hash(cfs_hlist_head_t *hash);
178
179 struct obd_capa *capa_add(cfs_hlist_head_t *hash,
180                           struct lustre_capa *capa);
181 struct obd_capa *capa_lookup(cfs_hlist_head_t *hash,
182                              struct lustre_capa *capa, int alive);
183
184 int capa_hmac(__u8 *hmac, struct lustre_capa *capa, __u8 *key);
185 int capa_encrypt_id(__u32 *d, __u32 *s, __u8 *key, int keylen);
186 int capa_decrypt_id(__u32 *d, __u32 *s, __u8 *key, int keylen);
187 void capa_cpy(void *dst, struct obd_capa *ocapa);
188 static inline struct obd_capa *alloc_capa(int site)
189 {
190 #ifdef __KERNEL__
191         struct obd_capa *ocapa;
192
193         if (unlikely(site != CAPA_SITE_CLIENT && site != CAPA_SITE_SERVER))
194                 return ERR_PTR(-EINVAL);
195
196         OBD_SLAB_ALLOC_PTR(ocapa, capa_cachep);
197         if (unlikely(!ocapa))
198                 return ERR_PTR(-ENOMEM);
199
200         CFS_INIT_LIST_HEAD(&ocapa->c_list);
201         cfs_atomic_set(&ocapa->c_refc, 1);
202         cfs_spin_lock_init(&ocapa->c_lock);
203         ocapa->c_site = site;
204         if (ocapa->c_site == CAPA_SITE_CLIENT)
205                 CFS_INIT_LIST_HEAD(&ocapa->u.cli.lli_list);
206         else
207                 CFS_INIT_HLIST_NODE(&ocapa->u.tgt.c_hash);
208
209         return ocapa;
210 #else
211         return ERR_PTR(-EOPNOTSUPP);
212 #endif
213 }
214
215 static inline struct obd_capa *capa_get(struct obd_capa *ocapa)
216 {
217         if (!ocapa)
218                 return NULL;
219
220         cfs_atomic_inc(&ocapa->c_refc);
221         return ocapa;
222 }
223
224 static inline void capa_put(struct obd_capa *ocapa)
225 {
226         if (!ocapa)
227                 return;
228
229         if (cfs_atomic_read(&ocapa->c_refc) == 0) {
230                 DEBUG_CAPA(D_ERROR, &ocapa->c_capa, "refc is 0 for");
231                 LBUG();
232         }
233
234         if (cfs_atomic_dec_and_test(&ocapa->c_refc)) {
235                 LASSERT(cfs_list_empty(&ocapa->c_list));
236                 if (ocapa->c_site == CAPA_SITE_CLIENT) {
237                         LASSERT(cfs_list_empty(&ocapa->u.cli.lli_list));
238                 } else {
239                         cfs_hlist_node_t *hnode;
240
241                         hnode = &ocapa->u.tgt.c_hash;
242                         LASSERT(!hnode->next && !hnode->pprev);
243                 }
244                 OBD_SLAB_FREE(ocapa, capa_cachep, sizeof(*ocapa));
245         }
246 }
247
248 static inline int open_flags_to_accmode(int flags)
249 {
250         int mode = flags;
251
252         if ((mode + 1) & O_ACCMODE)
253                 mode++;
254         if (mode & O_TRUNC)
255                 mode |= 2;
256
257         return mode;
258 }
259
260 static inline __u64 capa_open_opc(int mode)
261 {
262         return mode & FMODE_WRITE ? CAPA_OPC_OSS_WRITE : CAPA_OPC_OSS_READ;
263 }
264
265 static inline void set_capa_expiry(struct obd_capa *ocapa)
266 {
267         cfs_time_t expiry = cfs_time_sub((cfs_time_t)ocapa->c_capa.lc_expiry,
268                                          cfs_time_current_sec());
269         ocapa->c_expiry = cfs_time_add(cfs_time_current(),
270                                        cfs_time_seconds(expiry));
271 }
272
273 static inline int capa_is_expired_sec(struct lustre_capa *capa)
274 {
275         return (capa->lc_expiry - cfs_time_current_sec() <= 0);
276 }
277
278 static inline int capa_is_expired(struct obd_capa *ocapa)
279 {
280         return cfs_time_beforeq(ocapa->c_expiry, cfs_time_current());
281 }
282
283 static inline int capa_opc_supported(struct lustre_capa *capa, __u64 opc)
284 {
285         return (capa_opc(capa) & opc) == opc;
286 }
287
288 struct filter_capa_key {
289         cfs_list_t              k_list;
290         struct lustre_capa_key  k_key;
291 };
292
293 enum {
294         LC_ID_NONE      = 0,
295         LC_ID_PLAIN     = 1,
296         LC_ID_CONVERT   = 2
297 };
298
299 #define BYPASS_CAPA (struct lustre_capa *)ERR_PTR(-ENOENT)
300 #endif /* __LINUX_CAPA_H_ */