X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Finclude%2Flustre_capa.h;h=b665168d62ce6eee59b8ffa74dd7f54f9b7da47e;hb=051ca1bc6a561f8bac65e0cfa861ff48050e8bea;hp=9e71a21940d4e75ae5a2b398aaf075a7e5a7dbee;hpb=99293c489dc2330bbb8ce3734f575003d4812811;p=fs%2Flustre-release.git diff --git a/lustre/include/lustre_capa.h b/lustre/include/lustre_capa.h index 9e71a21..b665168 100644 --- a/lustre/include/lustre_capa.h +++ b/lustre/include/lustre_capa.h @@ -1,30 +1,51 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: +/* + * GPL HEADER START * - * Copyright (C) 2005 Cluster File Systems, Inc. - * Author: Lai Siyao + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * This file is part of Lustre, http://www.lustre.org. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 only, + * as published by the Free Software Foundation. * - * Lustre is free software; you can redistribute it and/or - * modify it under the terms of version 2 of the GNU General Public - * License as published by the Free Software Foundation. + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License version 2 for more details (a copy is included + * in the LICENSE file that accompanied this code). * - * Lustre is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * version 2 along with this program; If not, see + * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf * - * You should have received a copy of the GNU General Public License - * along with Lustre; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. * - * Lustre capability support. + * GPL HEADER END + */ +/* + * Copyright (c) 2007, 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/ + * Lustre is a trademark of Sun Microsystems, Inc. + * + * lustre/include/lustre_capa.h + * + * Author: Lai Siyao */ #ifndef __LINUX_CAPA_H_ #define __LINUX_CAPA_H_ +/** \defgroup capa capa + * + * @{ + */ + /* * capability */ @@ -50,27 +71,27 @@ struct capa_hmac_alg { } struct client_capa { - struct inode *inode; - struct list_head lli_list; /* link to lli_oss_capas */ + struct inode *inode; + cfs_list_t lli_list; /* link to lli_oss_capas */ }; struct target_capa { - struct hlist_node c_hash; /* link to capa hash */ + cfs_hlist_node_t c_hash; /* link to capa hash */ }; struct obd_capa { - struct list_head c_list; /* link to capa_list */ + cfs_list_t c_list; /* link to capa_list */ struct lustre_capa c_capa; /* capa */ - atomic_t c_refc; /* ref count */ + cfs_atomic_t c_refc; /* ref count */ cfs_time_t c_expiry; /* jiffies */ - spinlock_t c_lock; /* protect capa content */ - int c_site; + spinlock_t c_lock; /* protect capa content */ + int c_site; - union { - struct client_capa cli; - struct target_capa tgt; - } u; + union { + struct client_capa cli; + struct target_capa tgt; + } u; }; enum { @@ -79,115 +100,123 @@ enum { CAPA_SITE_MAX }; +static inline struct lu_fid *capa_fid(struct lustre_capa *capa) +{ + return &capa->lc_fid; +} + static inline __u64 capa_opc(struct lustre_capa *capa) { return capa->lc_opc; } -static inline __u32 capa_uid(struct lustre_capa *capa) +static inline __u64 capa_uid(struct lustre_capa *capa) { return capa->lc_uid; } -static inline struct lu_fid *capa_fid(struct lustre_capa *capa) +static inline __u64 capa_gid(struct lustre_capa *capa) { - return &capa->lc_fid; + return capa->lc_gid; } -static inline __u32 capa_keyid(struct lustre_capa *capa) +static inline __u32 capa_flags(struct lustre_capa *capa) { - return capa->lc_keyid; + return capa->lc_flags & 0xffffff; } -static inline __u64 capa_expiry(struct lustre_capa *capa) +static inline __u32 capa_alg(struct lustre_capa *capa) { - return capa->lc_expiry; + return (capa->lc_flags >> 24); } -static inline __u32 capa_flags(struct lustre_capa *capa) +static inline __u32 capa_keyid(struct lustre_capa *capa) { - return capa->lc_flags & 0xffffff; + return capa->lc_keyid; } -static inline __u32 capa_alg(struct lustre_capa *capa) +static inline __u64 capa_key_seq(struct lustre_capa_key *key) { - __u32 alg = capa->lc_flags; + return key->lk_seq; +} - return alg >> 24; +static inline __u32 capa_key_keyid(struct lustre_capa_key *key) +{ + return key->lk_keyid; } -static inline __u64 capa_key_mdsid(struct lustre_capa_key *key) +static inline __u32 capa_timeout(struct lustre_capa *capa) { - return key->lk_mdsid; + return capa->lc_timeout; } -static inline __u32 capa_key_keyid(struct lustre_capa_key *key) +static inline __u32 capa_expiry(struct lustre_capa *capa) { - return key->lk_keyid; + return capa->lc_expiry; } -#define DEBUG_CAPA(level, c, fmt, args...) \ +void _debug_capa(struct lustre_capa *, struct libcfs_debug_msg_data *, + const char *fmt, ... ); +#define DEBUG_CAPA(level, capa, fmt, args...) \ do { \ -CDEBUG(level, fmt " capability@%p uid %u opc "LPX64" fid "DFID" keyid %u " \ - "expiry "LPU64" flags %u alg %d\n", \ - ##args, c, capa_uid(c), capa_opc(c), PFID(capa_fid(c)), capa_keyid(c), \ - capa_expiry(c), capa_flags(c), capa_alg(c)); \ + if (((level) & D_CANTMASK) != 0 || \ + ((libcfs_debug & (level)) != 0 && \ + (libcfs_subsystem_debug & DEBUG_SUBSYSTEM) != 0)) { \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, level, NULL); \ + _debug_capa((capa), &msgdata, fmt, ##args); \ + } \ } while (0) #define DEBUG_CAPA_KEY(level, k, fmt, args...) \ do { \ -CDEBUG(level, fmt " capability key@%p mdsid "LPU64" keyid %u\n", \ - ##args, k, capa_key_mdsid(k), capa_key_keyid(k)); \ +CDEBUG(level, fmt " capability key@%p seq "LPU64" keyid %u\n", \ + ##args, k, capa_key_seq(k), capa_key_keyid(k)); \ } while (0) typedef int (* renew_capa_cb_t)(struct obd_capa *, struct lustre_capa *); /* obdclass/capa.c */ -extern struct list_head capa_list[]; +extern cfs_list_t capa_list[]; extern spinlock_t capa_lock; extern int capa_count[]; -extern cfs_mem_cache_t *capa_cachep; +extern struct kmem_cache *capa_cachep; -struct hlist_head *init_capa_hash(void); -void cleanup_capa_hash(struct hlist_head *hash); +cfs_hlist_head_t *init_capa_hash(void); +void cleanup_capa_hash(cfs_hlist_head_t *hash); -struct obd_capa *capa_add(struct hlist_head *hash, struct lustre_capa *capa); -struct obd_capa *capa_lookup(struct hlist_head *hash, struct lustre_capa *capa, - int alive); +struct obd_capa *capa_add(cfs_hlist_head_t *hash, + struct lustre_capa *capa); +struct obd_capa *capa_lookup(cfs_hlist_head_t *hash, + struct lustre_capa *capa, int alive); int capa_hmac(__u8 *hmac, struct lustre_capa *capa, __u8 *key); +int capa_encrypt_id(__u32 *d, __u32 *s, __u8 *key, int keylen); +int capa_decrypt_id(__u32 *d, __u32 *s, __u8 *key, int keylen); void capa_cpy(void *dst, struct obd_capa *ocapa); - -char *dump_capa_content(char *buf, char *key, int len); - static inline struct obd_capa *alloc_capa(int site) { #ifdef __KERNEL__ struct obd_capa *ocapa; - OBD_SLAB_ALLOC(ocapa, capa_cachep, GFP_KERNEL, sizeof(*ocapa)); - if (ocapa) { - atomic_set(&ocapa->c_refc, 0); - spin_lock_init(&ocapa->c_lock); - INIT_LIST_HEAD(&ocapa->c_list); - ocapa->c_site = site; - } - return ocapa; -#else - return NULL; -#endif -} + if (unlikely(site != CAPA_SITE_CLIENT && site != CAPA_SITE_SERVER)) + return ERR_PTR(-EINVAL); -static inline void free_capa(struct obd_capa *ocapa) -{ -#ifdef __KERNEL__ - if (atomic_read(&ocapa->c_refc)) { - DEBUG_CAPA(D_ERROR, &ocapa->c_capa, "refc %d for", - atomic_read(&ocapa->c_refc)); - LBUG(); - } - OBD_SLAB_FREE(ocapa, capa_cachep, sizeof(*ocapa)); + OBD_SLAB_ALLOC_PTR(ocapa, capa_cachep); + if (unlikely(!ocapa)) + return ERR_PTR(-ENOMEM); + + CFS_INIT_LIST_HEAD(&ocapa->c_list); + cfs_atomic_set(&ocapa->c_refc, 1); + spin_lock_init(&ocapa->c_lock); + ocapa->c_site = site; + if (ocapa->c_site == CAPA_SITE_CLIENT) + CFS_INIT_LIST_HEAD(&ocapa->u.cli.lli_list); + else + CFS_INIT_HLIST_NODE(&ocapa->u.tgt.c_hash); + + return ocapa; #else + return ERR_PTR(-EOPNOTSUPP); #endif } @@ -196,7 +225,7 @@ static inline struct obd_capa *capa_get(struct obd_capa *ocapa) if (!ocapa) return NULL; - atomic_inc(&ocapa->c_refc); + cfs_atomic_inc(&ocapa->c_refc); return ocapa; } @@ -205,11 +234,23 @@ static inline void capa_put(struct obd_capa *ocapa) if (!ocapa) return; - if (atomic_read(&ocapa->c_refc) == 0) { + if (cfs_atomic_read(&ocapa->c_refc) == 0) { DEBUG_CAPA(D_ERROR, &ocapa->c_capa, "refc is 0 for"); LBUG(); } - atomic_dec(&ocapa->c_refc); + + if (cfs_atomic_dec_and_test(&ocapa->c_refc)) { + LASSERT(cfs_list_empty(&ocapa->c_list)); + if (ocapa->c_site == CAPA_SITE_CLIENT) { + LASSERT(cfs_list_empty(&ocapa->u.cli.lli_list)); + } else { + cfs_hlist_node_t *hnode; + + hnode = &ocapa->u.tgt.c_hash; + LASSERT(!hnode->next && !hnode->pprev); + } + OBD_SLAB_FREE(ocapa, capa_cachep, sizeof(*ocapa)); + } } static inline int open_flags_to_accmode(int flags) @@ -237,6 +278,11 @@ static inline void set_capa_expiry(struct obd_capa *ocapa) cfs_time_seconds(expiry)); } +static inline int capa_is_expired_sec(struct lustre_capa *capa) +{ + return (capa->lc_expiry - cfs_time_current_sec() <= 0); +} + static inline int capa_is_expired(struct obd_capa *ocapa) { return cfs_time_beforeq(ocapa->c_expiry, cfs_time_current()); @@ -247,26 +293,36 @@ static inline int capa_opc_supported(struct lustre_capa *capa, __u64 opc) return (capa_opc(capa) & opc) == opc; } -static inline struct lustre_capa * -lustre_unpack_capa(struct lustre_msg *msg, unsigned int offset) -{ - struct lustre_capa *capa; - - capa = lustre_swab_buf(msg, offset, sizeof(*capa), - lustre_swab_lustre_capa); - if (capa == NULL) - CERROR("bufcount %u, bufsize %u\n", - lustre_msg_bufcount(msg), - (lustre_msg_bufcount(msg) <= offset) ? - -1 : lustre_msg_buflen(msg, offset)); - - return capa; -} - struct filter_capa_key { - struct list_head k_list; + cfs_list_t k_list; struct lustre_capa_key k_key; }; +enum lc_auth_id { + LC_ID_NONE = 0, + LC_ID_PLAIN = 1, + LC_ID_CONVERT = 2 +}; + #define BYPASS_CAPA (struct lustre_capa *)ERR_PTR(-ENOENT) + +enum { + LU_CAPAINFO_MAX = 5 +}; + +/** there are at most 5 FIDs in one operation, see rename, + * NOTE the last one is a temporary one used for is_subdir() */ +struct lu_capainfo { + enum lc_auth_id lci_auth; + __u32 lci_padding; + struct lu_fid lci_fid[LU_CAPAINFO_MAX]; + struct lustre_capa *lci_capa[LU_CAPAINFO_MAX]; +}; + +int lu_capainfo_init(void); +void lu_capainfo_fini(void); +struct lu_capainfo *lu_capainfo_get(const struct lu_env *env); + +/** @} capa */ + #endif /* __LINUX_CAPA_H_ */