X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fptlrpc%2Fsec_bulk.c;h=e93b901f4c3220ca20c138afdff07f8cde3e0156;hb=71bdcf99d7ab7571101b0478194e18dff9cb8e62;hp=bfce3e1b664fdad90f0fdd8735242e3b6747613c;hpb=3f90f344ae059b30e7d23e4fe554a985eb827b02;p=fs%2Flustre-release.git diff --git a/lustre/ptlrpc/sec_bulk.c b/lustre/ptlrpc/sec_bulk.c index bfce3e1..e93b901 100644 --- a/lustre/ptlrpc/sec_bulk.c +++ b/lustre/ptlrpc/sec_bulk.c @@ -104,7 +104,7 @@ static struct ptlrpc_enc_page_pool { /* * in-pool pages bookkeeping */ - cfs_spinlock_t epp_lock; /* protect following fields */ + spinlock_t epp_lock; /* protect following fields */ unsigned long epp_total_pages; /* total pages in pools */ unsigned long epp_free_pages; /* current pages available */ @@ -141,7 +141,7 @@ int sptlrpc_proc_read_enc_pool(char *page, char **start, off_t off, int count, { int rc; - cfs_spin_lock(&page_pools.epp_lock); + spin_lock(&page_pools.epp_lock); rc = snprintf(page, count, "physical pages: %lu\n" @@ -183,8 +183,8 @@ int sptlrpc_proc_read_enc_pool(char *page, char **start, off_t off, int count, page_pools.epp_st_max_wait, CFS_HZ ); - cfs_spin_unlock(&page_pools.epp_lock); - return rc; + spin_unlock(&page_pools.epp_lock); + return rc; } static void enc_pools_release_free_pages(long npages) @@ -238,8 +238,8 @@ static void enc_pools_release_free_pages(long npages) */ static int enc_pools_shrink(SHRINKER_ARGS(sc, nr_to_scan, gfp_mask)) { - if (unlikely(shrink_param(sc, nr_to_scan) != 0)) { - cfs_spin_lock(&page_pools.epp_lock); + if (unlikely(shrink_param(sc, nr_to_scan) != 0)) { + spin_lock(&page_pools.epp_lock); shrink_param(sc, nr_to_scan) = min_t(unsigned long, shrink_param(sc, nr_to_scan), page_pools.epp_free_pages - @@ -254,23 +254,23 @@ static int enc_pools_shrink(SHRINKER_ARGS(sc, nr_to_scan, gfp_mask)) page_pools.epp_st_shrinks++; page_pools.epp_last_shrink = cfs_time_current_sec(); } - cfs_spin_unlock(&page_pools.epp_lock); - } - - /* - * if no pool access for a long time, we consider it's fully idle. - * a little race here is fine. - */ - if (unlikely(cfs_time_current_sec() - page_pools.epp_last_access > - CACHE_QUIESCENT_PERIOD)) { - cfs_spin_lock(&page_pools.epp_lock); - page_pools.epp_idle_idx = IDLE_IDX_MAX; - cfs_spin_unlock(&page_pools.epp_lock); - } - - LASSERT(page_pools.epp_idle_idx <= IDLE_IDX_MAX); - return max((int) page_pools.epp_free_pages - PTLRPC_MAX_BRW_PAGES, 0) * - (IDLE_IDX_MAX - page_pools.epp_idle_idx) / IDLE_IDX_MAX; + spin_unlock(&page_pools.epp_lock); + } + + /* + * if no pool access for a long time, we consider it's fully idle. + * a little race here is fine. + */ + if (unlikely(cfs_time_current_sec() - page_pools.epp_last_access > + CACHE_QUIESCENT_PERIOD)) { + spin_lock(&page_pools.epp_lock); + page_pools.epp_idle_idx = IDLE_IDX_MAX; + spin_unlock(&page_pools.epp_lock); + } + + LASSERT(page_pools.epp_idle_idx <= IDLE_IDX_MAX); + return max((int)page_pools.epp_free_pages - PTLRPC_MAX_BRW_PAGES, 0) * + (IDLE_IDX_MAX - page_pools.epp_idle_idx) / IDLE_IDX_MAX; } static inline @@ -321,7 +321,7 @@ static void enc_pools_insert(cfs_page_t ***pools, int npools, int npages) LASSERT(npages_to_npools(npages) == npools); LASSERT(page_pools.epp_growing); - cfs_spin_lock(&page_pools.epp_lock); + spin_lock(&page_pools.epp_lock); /* * (1) fill all the free slots of current pools. @@ -388,20 +388,20 @@ static void enc_pools_insert(cfs_page_t ***pools, int npools, int npages) CDEBUG(D_SEC, "add %d pages to total %lu\n", npages, page_pools.epp_total_pages); - cfs_spin_unlock(&page_pools.epp_lock); + spin_unlock(&page_pools.epp_lock); } static int enc_pools_add_pages(int npages) { - static CFS_DEFINE_MUTEX(add_pages_mutex); - cfs_page_t ***pools; - int npools, alloced = 0; - int i, j, rc = -ENOMEM; + static DEFINE_MUTEX(add_pages_mutex); + cfs_page_t ***pools; + int npools, alloced = 0; + int i, j, rc = -ENOMEM; - if (npages < PTLRPC_MAX_BRW_PAGES) - npages = PTLRPC_MAX_BRW_PAGES; + if (npages < PTLRPC_MAX_BRW_PAGES) + npages = PTLRPC_MAX_BRW_PAGES; - cfs_mutex_lock(&add_pages_mutex); + mutex_lock(&add_pages_mutex); if (npages + page_pools.epp_total_pages > page_pools.epp_max_pages) npages = page_pools.epp_max_pages - page_pools.epp_total_pages; @@ -443,7 +443,7 @@ out: CERROR("Failed to allocate %d enc pages\n", npages); } - cfs_mutex_unlock(&add_pages_mutex); + mutex_unlock(&add_pages_mutex); return rc; } @@ -514,7 +514,7 @@ int sptlrpc_enc_pool_get_pages(struct ptlrpc_bulk_desc *desc) if (desc->bd_enc_iov == NULL) return -ENOMEM; - cfs_spin_lock(&page_pools.epp_lock); + spin_lock(&page_pools.epp_lock); page_pools.epp_st_access++; again: @@ -530,9 +530,9 @@ again: if (enc_pools_should_grow(desc->bd_iov_count, now)) { page_pools.epp_growing = 1; - cfs_spin_unlock(&page_pools.epp_lock); - enc_pools_add_pages(page_pools.epp_pages_short / 2); - cfs_spin_lock(&page_pools.epp_lock); + spin_unlock(&page_pools.epp_lock); + enc_pools_add_pages(page_pools.epp_pages_short / 2); + spin_lock(&page_pools.epp_lock); page_pools.epp_growing = 0; @@ -547,11 +547,11 @@ again: cfs_waitlink_init(&waitlink); cfs_waitq_add(&page_pools.epp_waitq, &waitlink); - cfs_spin_unlock(&page_pools.epp_lock); - cfs_waitq_wait(&waitlink, CFS_TASK_UNINT); - cfs_waitq_del(&page_pools.epp_waitq, &waitlink); - LASSERT(page_pools.epp_waitqlen > 0); - cfs_spin_lock(&page_pools.epp_lock); + spin_unlock(&page_pools.epp_lock); + cfs_waitq_wait(&waitlink, CFS_TASK_UNINT); + cfs_waitq_del(&page_pools.epp_waitq, &waitlink); + LASSERT(page_pools.epp_waitqlen > 0); + spin_lock(&page_pools.epp_lock); page_pools.epp_waitqlen--; } @@ -603,8 +603,8 @@ again: page_pools.epp_last_access = cfs_time_current_sec(); - cfs_spin_unlock(&page_pools.epp_lock); - return 0; + spin_unlock(&page_pools.epp_lock); + return 0; } EXPORT_SYMBOL(sptlrpc_enc_pool_get_pages); @@ -618,7 +618,7 @@ void sptlrpc_enc_pool_put_pages(struct ptlrpc_bulk_desc *desc) LASSERT(desc->bd_iov_count > 0); - cfs_spin_lock(&page_pools.epp_lock); + spin_lock(&page_pools.epp_lock); p_idx = page_pools.epp_free_pages / PAGES_PER_POOL; g_idx = page_pools.epp_free_pages % PAGES_PER_POOL; @@ -645,11 +645,11 @@ void sptlrpc_enc_pool_put_pages(struct ptlrpc_bulk_desc *desc) enc_pools_wakeup(); - cfs_spin_unlock(&page_pools.epp_lock); + spin_unlock(&page_pools.epp_lock); - OBD_FREE(desc->bd_enc_iov, - desc->bd_iov_count * sizeof(*desc->bd_enc_iov)); - desc->bd_enc_iov = NULL; + OBD_FREE(desc->bd_enc_iov, + desc->bd_iov_count * sizeof(*desc->bd_enc_iov)); + desc->bd_enc_iov = NULL; } EXPORT_SYMBOL(sptlrpc_enc_pool_put_pages); @@ -660,25 +660,25 @@ EXPORT_SYMBOL(sptlrpc_enc_pool_put_pages); */ int sptlrpc_enc_pool_add_user(void) { - int need_grow = 0; - - cfs_spin_lock(&page_pools.epp_lock); - if (page_pools.epp_growing == 0 && page_pools.epp_total_pages == 0) { - page_pools.epp_growing = 1; - need_grow = 1; - } - cfs_spin_unlock(&page_pools.epp_lock); - - if (need_grow) { - enc_pools_add_pages(PTLRPC_MAX_BRW_PAGES + - PTLRPC_MAX_BRW_PAGES); - - cfs_spin_lock(&page_pools.epp_lock); - page_pools.epp_growing = 0; - enc_pools_wakeup(); - cfs_spin_unlock(&page_pools.epp_lock); - } - return 0; + int need_grow = 0; + + spin_lock(&page_pools.epp_lock); + if (page_pools.epp_growing == 0 && page_pools.epp_total_pages == 0) { + page_pools.epp_growing = 1; + need_grow = 1; + } + spin_unlock(&page_pools.epp_lock); + + if (need_grow) { + enc_pools_add_pages(PTLRPC_MAX_BRW_PAGES + + PTLRPC_MAX_BRW_PAGES); + + spin_lock(&page_pools.epp_lock); + page_pools.epp_growing = 0; + enc_pools_wakeup(); + spin_unlock(&page_pools.epp_lock); + } + return 0; } EXPORT_SYMBOL(sptlrpc_enc_pool_add_user); @@ -725,7 +725,7 @@ int sptlrpc_enc_pool_init(void) page_pools.epp_last_shrink = cfs_time_current_sec(); page_pools.epp_last_access = cfs_time_current_sec(); - cfs_spin_lock_init(&page_pools.epp_lock); + spin_lock_init(&page_pools.epp_lock); page_pools.epp_total_pages = 0; page_pools.epp_free_pages = 0; @@ -803,55 +803,25 @@ void sptlrpc_enc_pool_fini(void) } #endif -/**************************************** - * Helpers to assist policy modules to * - * implement checksum funcationality * - ****************************************/ - -static struct sptlrpc_hash_type hash_types[] = { - [BULK_HASH_ALG_NULL] = { "null", "null", 0 }, - [BULK_HASH_ALG_ADLER32] = { "adler32", "adler32", 4 }, - [BULK_HASH_ALG_CRC32] = { "crc32", "crc32", 4 }, - [BULK_HASH_ALG_MD5] = { "md5", "md5", 16 }, - [BULK_HASH_ALG_SHA1] = { "sha1", "sha1", 20 }, - [BULK_HASH_ALG_SHA256] = { "sha256", "sha256", 32 }, - [BULK_HASH_ALG_SHA384] = { "sha384", "sha384", 48 }, - [BULK_HASH_ALG_SHA512] = { "sha512", "sha512", 64 }, +static int cfs_hash_alg_id[] = { + [BULK_HASH_ALG_NULL] = CFS_HASH_ALG_NULL, + [BULK_HASH_ALG_ADLER32] = CFS_HASH_ALG_ADLER32, + [BULK_HASH_ALG_CRC32] = CFS_HASH_ALG_CRC32, + [BULK_HASH_ALG_MD5] = CFS_HASH_ALG_MD5, + [BULK_HASH_ALG_SHA1] = CFS_HASH_ALG_SHA1, + [BULK_HASH_ALG_SHA256] = CFS_HASH_ALG_SHA256, + [BULK_HASH_ALG_SHA384] = CFS_HASH_ALG_SHA384, + [BULK_HASH_ALG_SHA512] = CFS_HASH_ALG_SHA512, }; - -const struct sptlrpc_hash_type *sptlrpc_get_hash_type(__u8 hash_alg) -{ - struct sptlrpc_hash_type *ht; - - if (hash_alg < BULK_HASH_ALG_MAX) { - ht = &hash_types[hash_alg]; - if (ht->sht_tfm_name) - return ht; - } - return NULL; -} -EXPORT_SYMBOL(sptlrpc_get_hash_type); - const char * sptlrpc_get_hash_name(__u8 hash_alg) { - const struct sptlrpc_hash_type *ht; - - ht = sptlrpc_get_hash_type(hash_alg); - if (ht) - return ht->sht_name; - else - return "unknown"; + return cfs_crypto_hash_name(cfs_hash_alg_id[hash_alg]); } EXPORT_SYMBOL(sptlrpc_get_hash_name); __u8 sptlrpc_get_hash_alg(const char *algname) { - int i; - - for (i = 0; i < BULK_HASH_ALG_MAX; i++) - if (!strcmp(hash_types[i].sht_name, algname)) - break; - return i; + return cfs_crypto_hash_alg(algname); } EXPORT_SYMBOL(sptlrpc_get_hash_alg); @@ -893,149 +863,52 @@ int bulk_sec_desc_unpack(struct lustre_msg *msg, int offset, int swabbed) } EXPORT_SYMBOL(bulk_sec_desc_unpack); -#ifdef __KERNEL__ - -#ifdef HAVE_ADLER -static int do_bulk_checksum_adler32(struct ptlrpc_bulk_desc *desc, void *buf) +int sptlrpc_get_bulk_checksum(struct ptlrpc_bulk_desc *desc, __u8 alg, + void *buf, int buflen) { - struct page *page; - int off; - char *ptr; - __u32 adler32 = 1; - int len, i; - - for (i = 0; i < desc->bd_iov_count; i++) { - page = desc->bd_iov[i].kiov_page; - off = desc->bd_iov[i].kiov_offset & ~CFS_PAGE_MASK; - ptr = cfs_kmap(page) + off; - len = desc->bd_iov[i].kiov_len; - - adler32 = adler32(adler32, ptr, len); - - cfs_kunmap(page); - } - - adler32 = cpu_to_le32(adler32); - memcpy(buf, &adler32, sizeof(adler32)); - return 0; -} -#endif + struct cfs_crypto_hash_desc *hdesc; + int hashsize; + char hashbuf[64]; + unsigned int bufsize; + int i, err; -static int do_bulk_checksum_crc32(struct ptlrpc_bulk_desc *desc, void *buf) -{ - struct page *page; - int off; - char *ptr; - __u32 crc32 = ~0; - int len, i; + LASSERT(alg > BULK_HASH_ALG_NULL && alg < BULK_HASH_ALG_MAX); + LASSERT(buflen >= 4); - for (i = 0; i < desc->bd_iov_count; i++) { - page = desc->bd_iov[i].kiov_page; - off = desc->bd_iov[i].kiov_offset & ~CFS_PAGE_MASK; - ptr = cfs_kmap(page) + off; - len = desc->bd_iov[i].kiov_len; + hdesc = cfs_crypto_hash_init(cfs_hash_alg_id[alg], NULL, 0); + if (IS_ERR(hdesc)) { + CERROR("Unable to initialize checksum hash %s\n", + cfs_crypto_hash_name(cfs_hash_alg_id[alg])); + return PTR_ERR(hdesc); + } - crc32 = crc32_le(crc32, ptr, len); + hashsize = cfs_crypto_hash_digestsize(cfs_hash_alg_id[alg]); - cfs_kunmap(page); - } - - crc32 = cpu_to_le32(crc32); - memcpy(buf, &crc32, sizeof(crc32)); - return 0; -} - -int sptlrpc_get_bulk_checksum(struct ptlrpc_bulk_desc *desc, __u8 alg, - void *buf, int buflen) -{ - struct hash_desc hdesc; - int hashsize; - char hashbuf[64]; - struct scatterlist sl; - int i; - - LASSERT(alg > BULK_HASH_ALG_NULL && alg < BULK_HASH_ALG_MAX); - LASSERT(buflen >= 4); - - switch (alg) { - case BULK_HASH_ALG_ADLER32: -#ifdef HAVE_ADLER - return do_bulk_checksum_adler32(desc, buf); + for (i = 0; i < desc->bd_iov_count; i++) { +#ifdef __KERNEL__ + cfs_crypto_hash_update_page(hdesc, desc->bd_iov[i].kiov_page, + desc->bd_iov[i].kiov_offset & ~CFS_PAGE_MASK, + desc->bd_iov[i].kiov_len); #else - CERROR("Adler32 not supported\n"); - return -EINVAL; + cfs_crypto_hash_update(hdesc, desc->bd_iov[i].iov_base, + desc->bd_iov[i].iov_len); #endif - case BULK_HASH_ALG_CRC32: - return do_bulk_checksum_crc32(desc, buf); - } - - hdesc.tfm = ll_crypto_alloc_hash(hash_types[alg].sht_tfm_name, 0, 0); - if (hdesc.tfm == NULL) { - CERROR("Unable to allocate TFM %s\n", hash_types[alg].sht_name); - return -ENOMEM; - } - - hdesc.flags = 0; - ll_crypto_hash_init(&hdesc); - - hashsize = ll_crypto_hash_digestsize(hdesc.tfm); - - for (i = 0; i < desc->bd_iov_count; i++) { - sg_set_page(&sl, desc->bd_iov[i].kiov_page, - desc->bd_iov[i].kiov_len, - desc->bd_iov[i].kiov_offset & ~CFS_PAGE_MASK); - ll_crypto_hash_update(&hdesc, &sl, sl.length); - } - - if (hashsize > buflen) { - ll_crypto_hash_final(&hdesc, hashbuf); - memcpy(buf, hashbuf, buflen); - } else { - ll_crypto_hash_final(&hdesc, buf); - } - - ll_crypto_free_hash(hdesc.tfm); - return 0; + } + if (hashsize > buflen) { + bufsize = sizeof(hashbuf); + err = cfs_crypto_hash_final(hdesc, (unsigned char *)hashbuf, + &bufsize); + memcpy(buf, hashbuf, buflen); + } else { + bufsize = buflen; + err = cfs_crypto_hash_final(hdesc, (unsigned char *)buf, + &bufsize); + } + + if (err) + cfs_crypto_hash_final(hdesc, NULL, NULL); + return err; } EXPORT_SYMBOL(sptlrpc_get_bulk_checksum); -#else /* !__KERNEL__ */ - -int sptlrpc_get_bulk_checksum(struct ptlrpc_bulk_desc *desc, __u8 alg, - void *buf, int buflen) -{ - __u32 csum32; - int i; - - LASSERT(alg == BULK_HASH_ALG_ADLER32 || alg == BULK_HASH_ALG_CRC32); - - if (alg == BULK_HASH_ALG_ADLER32) - csum32 = 1; - else - csum32 = ~0; - - for (i = 0; i < desc->bd_iov_count; i++) { - unsigned char *ptr = desc->bd_iov[i].iov_base; - int len = desc->bd_iov[i].iov_len; - - switch (alg) { - case BULK_HASH_ALG_ADLER32: -#ifdef HAVE_ADLER - csum32 = adler32(csum32, ptr, len); -#else - CERROR("Adler32 not supported\n"); - return -EINVAL; -#endif - break; - case BULK_HASH_ALG_CRC32: - csum32 = crc32_le(csum32, ptr, len); - break; - } - } - - csum32 = cpu_to_le32(csum32); - memcpy(buf, &csum32, sizeof(csum32)); - return 0; -} -#endif /* __KERNEL__ */