X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Finclude%2Flinux%2Flustre_compat25.h;h=b6c149677883ece683483bfcef54647c1b77dd59;hp=633b7b0d9cfad1d51b2fa6bc5ce3c0e9d80cd140;hb=cb84e877a145717c060d6f4813862ab537858592;hpb=903f02ad3cb37940b1cadce598a2a802b940ad37 diff --git a/lustre/include/linux/lustre_compat25.h b/lustre/include/linux/lustre_compat25.h index 633b7b0..b6c1496 100644 --- a/lustre/include/linux/lustre_compat25.h +++ b/lustre/include/linux/lustre_compat25.h @@ -1,23 +1,37 @@ /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- * vim:expandtab:shiftwidth=8:tabstop=8: * - * Copyright (c) 2003 Cluster File Systems, Inc. + * GPL HEADER START * - * This file is part of Lustre, http://www.lustre.org. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * 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 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 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. + * 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). * - * 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. + * 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 * + * 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. + * + * GPL HEADER END + */ +/* + * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Use is subject to license terms. + */ +/* + * This file is part of Lustre, http://www.lustre.org/ + * Lustre is a trademark of Sun Microsystems, Inc. */ #ifndef _LINUX_COMPAT25_H @@ -25,8 +39,8 @@ #ifdef __KERNEL__ -#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,5) -#error Sorry, Lustre requires at Linux kernel version 2.6.5 or later +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,9) +#error sorry, lustre requires at least linux kernel 2.6.9 or later #endif #include @@ -182,8 +196,14 @@ static inline int cleanup_group_info(void) #include -#ifndef HAVE___D_REHASH -#define __d_rehash(dentry, lock) d_rehash_cond(dentry, lock) +#if !defined(HAVE_D_REHASH_COND) && defined(HAVE___D_REHASH) +#define d_rehash_cond(dentry, lock) __d_rehash(dentry, lock) +extern void __d_rehash(struct dentry *dentry, int lock); +#endif + +#if !defined(HAVE_D_MOVE_LOCKED) && defined(HAVE___D_MOVE) +#define d_move_locked(dentry, target) __d_move(dentry, target) +extern void __d_move(struct dentry *dentry, struct dentry *target); #endif #ifdef HAVE_CAN_SLEEP_ARG @@ -195,7 +215,8 @@ static inline int cleanup_group_info(void) #endif #define CheckWriteback(page, cmd) \ - (!(!PageWriteback(page) && cmd == OBD_BRW_WRITE)) + ((!PageWriteback(page) && (cmd & OBD_BRW_READ)) || \ + (PageWriteback(page) && (cmd & OBD_BRW_WRITE))) #ifdef HAVE_PAGE_LIST static inline int mapping_has_pages(struct address_space *mapping) @@ -234,7 +255,13 @@ static inline int mapping_has_pages(struct address_space *mapping) dentry->d_flags |= flags; \ spin_unlock(&dentry->d_lock); \ } while(0) -#define ll_vfs_symlink(dir, dentry, path, mode) vfs_symlink(dir, dentry, path, mode) +#ifdef HAVE_SECURITY_PLUG +#define ll_vfs_symlink(dir, dentry, mnt, path, mode) \ + vfs_symlink(dir, dentry, mnt, path, mode) +#else +#define ll_vfs_symlink(dir, dentry, mnt, path, mode) \ + vfs_symlink(dir, dentry, path, mode) +#endif #endif #ifndef container_of @@ -371,5 +398,234 @@ int ll_unregister_blkdev(unsigned int dev, const char *name) #define ll_invalidate_bdev(a,b) invalidate_bdev((a)) #endif +#ifdef HAVE_INODE_BLKSIZE +#define ll_inode_blksize(a) (a)->i_blksize +#else +#define ll_inode_blksize(a) (1<<(a)->i_blkbits) +#endif + +#ifdef HAVE_FS_RENAME_DOES_D_MOVE +#define LL_RENAME_DOES_D_MOVE FS_RENAME_DOES_D_MOVE +#else +#define LL_RENAME_DOES_D_MOVE FS_ODD_RENAME +#endif + +/* add a lustre compatible layer for crypto API */ +#include +#ifdef HAVE_ASYNC_BLOCK_CIPHER +#define ll_crypto_hash crypto_hash +#define ll_crypto_cipher crypto_blkcipher +#define ll_crypto_alloc_hash(name, type, mask) crypto_alloc_hash(name, type, mask) +#define ll_crypto_hash_setkey(tfm, key, keylen) crypto_hash_setkey(tfm, key, keylen) +#define ll_crypto_hash_init(desc) crypto_hash_init(desc) +#define ll_crypto_hash_update(desc, sl, bytes) crypto_hash_update(desc, sl, bytes) +#define ll_crypto_hash_final(desc, out) crypto_hash_final(desc, out) +#define ll_crypto_alloc_blkcipher(name, type, mask) \ + crypto_alloc_blkcipher(name ,type, mask) +#define ll_crypto_blkcipher_setkey(tfm, key, keylen) \ + crypto_blkcipher_setkey(tfm, key, keylen) +#define ll_crypto_blkcipher_set_iv(tfm, src, len) \ + crypto_blkcipher_set_iv(tfm, src, len) +#define ll_crypto_blkcipher_get_iv(tfm, dst, len) \ + crypto_blkcipher_get_iv(tfm, dst, len) +#define ll_crypto_blkcipher_encrypt(desc, dst, src, bytes) \ + crypto_blkcipher_encrypt(desc, dst, src, bytes) +#define ll_crypto_blkcipher_decrypt(desc, dst, src, bytes) \ + crypto_blkcipher_decrypt(desc, dst, src, bytes) +#define ll_crypto_blkcipher_encrypt_iv(desc, dst, src, bytes) \ + crypto_blkcipher_encrypt_iv(desc, dst, src, bytes) +#define ll_crypto_blkcipher_decrypt_iv(desc, dst, src, bytes) \ + crypto_blkcipher_decrypt_iv(desc, dst, src, bytes) + +static inline int ll_crypto_hmac(struct ll_crypto_hash *tfm, + u8 *key, unsigned int *keylen, + struct scatterlist *sg, + unsigned int size, u8 *result) +{ + struct hash_desc desc; + int rv; + desc.tfm = tfm; + desc.flags = 0; + rv = crypto_hash_setkey(desc.tfm, key, *keylen); + if (rv) { + CERROR("failed to hash setkey: %d\n", rv); + return rv; + } + return crypto_hash_digest(&desc, sg, size, result); +} +static inline +unsigned int crypto_tfm_alg_max_keysize(struct crypto_blkcipher *tfm) +{ + return crypto_blkcipher_tfm(tfm)->__crt_alg->cra_blkcipher.max_keysize; +} +static inline +unsigned int crypto_tfm_alg_min_keysize(struct crypto_blkcipher *tfm) +{ + return crypto_blkcipher_tfm(tfm)->__crt_alg->cra_blkcipher.min_keysize; +} + +#define ll_crypto_hash_blocksize(tfm) crypto_hash_blocksize(tfm) +#define ll_crypto_hash_digestsize(tfm) crypto_hash_digestsize(tfm) +#define ll_crypto_blkcipher_ivsize(tfm) crypto_blkcipher_ivsize(tfm) +#define ll_crypto_blkcipher_blocksize(tfm) crypto_blkcipher_blocksize(tfm) +#define ll_crypto_free_hash(tfm) crypto_free_hash(tfm) +#define ll_crypto_free_blkcipher(tfm) crypto_free_blkcipher(tfm) +#else /* HAVE_ASYNC_BLOCK_CIPHER */ +#include +#define ll_crypto_hash crypto_tfm +#define ll_crypto_cipher crypto_tfm +struct hash_desc { + struct ll_crypto_hash *tfm; + u32 flags; +}; +struct blkcipher_desc { + struct ll_crypto_cipher *tfm; + void *info; + u32 flags; +}; +#define ll_crypto_blkcipher_setkey(tfm, key, keylen) \ + crypto_cipher_setkey(tfm, key, keylen) +#define ll_crypto_blkcipher_set_iv(tfm, src, len) \ + crypto_cipher_set_iv(tfm, src, len) +#define ll_crypto_blkcipher_get_iv(tfm, dst, len) \ + crypto_cipher_get_iv(tfm, dst, len) +#define ll_crypto_blkcipher_encrypt(desc, dst, src, bytes) \ + crypto_cipher_encrypt((desc)->tfm, dst, src, bytes) +#define ll_crypto_blkcipher_decrypt(desc, dst, src, bytes) \ + crypto_cipher_decrypt((desc)->tfm, dst, src, bytes) +#define ll_crypto_blkcipher_decrypt_iv(desc, dst, src, bytes) \ + crypto_cipher_decrypt_iv((desc)->tfm, dst, src, bytes, (desc)->info) +#define ll_crypto_blkcipher_encrypt_iv(desc, dst, src, bytes) \ + crypto_cipher_encrypt_iv((desc)->tfm, dst, src, bytes, (desc)->info) + +extern struct ll_crypto_cipher *ll_crypto_alloc_blkcipher( + const char * algname, u32 type, u32 mask); +static inline +struct ll_crypto_hash *ll_crypto_alloc_hash(const char *alg, u32 type, u32 mask) +{ + char buf[CRYPTO_MAX_ALG_NAME + 1]; + const char *pan = alg; + + if (strncmp("hmac(", alg, 5) == 0) { + char *vp = strnchr(alg, CRYPTO_MAX_ALG_NAME, ')'); + if (vp) { + memcpy(buf, alg+ 5, vp - alg- 5); + buf[vp - alg - 5] = 0x00; + pan = buf; + } + } + return crypto_alloc_tfm(pan, 0); +} +static inline int ll_crypto_hash_init(struct hash_desc *desc) +{ + crypto_digest_init(desc->tfm); return 0; +} +static inline int ll_crypto_hash_update(struct hash_desc *desc, + struct scatterlist *sg, + unsigned int nbytes) +{ + struct scatterlist *sl = sg; + unsigned int count; + /* + * This way is very weakness. We must ensure that + * the sum of sg[0..i]->length isn't greater than nbytes. + * In the upstream kernel the crypto_hash_update() also + * via the nbytes computed the count of sg[...]. + * The old style is more safely. but it gone. + */ + for (count = 0; nbytes > 0; count ++, sl ++) { + nbytes -= sl->length; + } + crypto_digest_update(desc->tfm, sg, count); return 0; +} +static inline int ll_crypto_hash_final(struct hash_desc *desc, u8 *out) +{ + crypto_digest_final(desc->tfm, out); return 0; +} +static inline int ll_crypto_hmac(struct crypto_tfm *tfm, + u8 *key, unsigned int *keylen, + struct scatterlist *sg, + unsigned int nbytes, + u8 *out) +{ + struct scatterlist *sl = sg; + int count; + for (count = 0; nbytes > 0; count ++, sl ++) { + nbytes -= sl->length; + } + crypto_hmac(tfm, key, keylen, sg, count, out); + return 0; +} + +#define ll_crypto_hash_setkey(tfm, key, keylen) crypto_digest_setkey(tfm, key, keylen) +#define ll_crypto_blkcipher_blocksize(tfm) crypto_tfm_alg_blocksize(tfm) +#define ll_crypto_blkcipher_ivsize(tfm) crypto_tfm_alg_ivsize(tfm) +#define ll_crypto_hash_digestsize(tfm) crypto_tfm_alg_digestsize(tfm) +#define ll_crypto_hash_blocksize(tfm) crypto_tfm_alg_blocksize(tfm) +#define ll_crypto_free_hash(tfm) crypto_free_tfm(tfm) +#define ll_crypto_free_blkcipher(tfm) crypto_free_tfm(tfm) +#endif /* HAVE_ASYNC_BLOCK_CIPHER */ + +#ifdef HAVE_SECURITY_PLUG +#define ll_remove_suid(inode,mnt) remove_suid(inode,mnt) +#define ll_vfs_rmdir(dir,entry,mnt) vfs_rmdir(dir,entry,mnt) +#define ll_vfs_mkdir(inode,dir,mnt,mode) vfs_mkdir(inode,dir,mnt,mode) +#define ll_vfs_link(old,mnt,dir,new,mnt1) vfs_link(old,mnt,dir,new,mnt1) +#define ll_vfs_unlink(inode,entry,mnt) vfs_unlink(inode,entry,mnt) +#define ll_vfs_mknod(dir,entry,mnt,mode,dev) \ + vfs_mknod(dir,entry,mnt,mode,dev) +#define ll_security_inode_unlink(dir,entry,mnt) \ + security_inode_unlink(dir,entry,mnt) +#define ll_vfs_rename(old,old_dir,mnt,new,new_dir,mnt1) \ + vfs_rename(old,old_dir,mnt,new,new_dir,mnt1) +#else +#define ll_remove_suid(inode,mnt) remove_suid(inode) +#define ll_vfs_rmdir(dir,entry,mnt) vfs_rmdir(dir,entry) +#define ll_vfs_mkdir(inode,dir,mnt,mode) vfs_mkdir(inode,dir,mode) +#define ll_vfs_link(old,mnt,dir,new,mnt1) vfs_link(old,dir,new) +#define ll_vfs_unlink(inode,entry,mnt) vfs_unlink(inode,entry) +#define ll_vfs_mknod(dir,entry,mnt,mode,dev) vfs_mknod(dir,entry,mode,dev) +#define ll_security_inode_unlink(dir,entry,mnt) security_inode_unlink(dir,entry) +#define ll_vfs_rename(old,old_dir,mnt,new,new_dir,mnt1) \ + vfs_rename(old,old_dir,new,new_dir) +#endif + +#ifndef get_cpu +#ifdef CONFIG_PREEMPT +#define get_cpu() ({ preempt_disable(); smp_processor_id(); }) +#define put_cpu() preempt_enable() +#else +#define get_cpu() smp_processor_id() +#define put_cpu() +#endif +#endif /* get_cpu & put_cpu */ + +#ifndef for_each_possible_cpu +#define for_each_possible_cpu(i) for_each_cpu(i) +#endif + +#ifndef cpu_to_node +#define cpu_to_node(cpu) 0 +#endif + +#ifndef abs +static inline int abs(int x) +{ + return (x < 0) ? -x : x; +} +#endif + +#ifndef labs +static inline long labs(long x) +{ + return (x < 0) ? -x : x; +} +#endif + +/* Using kernel fls(). Userspace will use one defined in user-bitops.h. */ +#ifndef __fls +#define __fls fls +#endif + #endif /* __KERNEL__ */ #endif /* _COMPAT25_H */