X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;ds=sidebyside;f=lustre%2Fptlrpc%2Fsec_bulk.c;h=9e5fb01855724b7d33dfc82c28f07998c7619067;hb=4f91d5161d005eed6ff7a9fe6abea99690f4bcb7;hp=a131099c3a10f35787e654cbd679b2e3caf1daeb;hpb=62ef9c949753efb9535fa5b1eb2eb38ec663917f;p=fs%2Flustre-release.git diff --git a/lustre/ptlrpc/sec_bulk.c b/lustre/ptlrpc/sec_bulk.c index a131099..9e5fb01 100644 --- a/lustre/ptlrpc/sec_bulk.c +++ b/lustre/ptlrpc/sec_bulk.c @@ -26,8 +26,10 @@ * GPL HEADER END */ /* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2011, Whamcloud, Inc. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -107,7 +109,7 @@ static struct ptlrpc_enc_page_pool { /* * in-pool pages bookkeeping */ - spinlock_t epp_lock; /* protect following fields */ + cfs_spinlock_t epp_lock; /* protect following fields */ unsigned long epp_total_pages; /* total pages in pools */ unsigned long epp_free_pages; /* current pages available */ @@ -132,8 +134,8 @@ static struct ptlrpc_enc_page_pool { /* * memory shrinker */ -const int pools_shrinker_seeks = DEFAULT_SEEKS; -static struct shrinker *pools_shrinker = NULL; +const int pools_shrinker_seeks = CFS_DEFAULT_SEEKS; +static struct cfs_shrinker *pools_shrinker = NULL; /* @@ -144,7 +146,7 @@ int sptlrpc_proc_read_enc_pool(char *page, char **start, off_t off, int count, { int rc; - spin_lock(&page_pools.epp_lock); + cfs_spin_lock(&page_pools.epp_lock); rc = snprintf(page, count, "physical pages: %lu\n" @@ -166,7 +168,7 @@ int sptlrpc_proc_read_enc_pool(char *page, char **start, off_t off, int count, "max waitqueue depth: %u\n" "max wait time: "CFS_TIME_T"/%u\n" , - num_physpages, + cfs_num_physpages, PAGES_PER_POOL, page_pools.epp_max_pages, page_pools.epp_max_pools, @@ -183,10 +185,10 @@ int sptlrpc_proc_read_enc_pool(char *page, char **start, off_t off, int count, page_pools.epp_st_missings, page_pools.epp_st_lowfree, page_pools.epp_st_max_wqlen, - page_pools.epp_st_max_wait, HZ + page_pools.epp_st_max_wait, CFS_HZ ); - spin_unlock(&page_pools.epp_lock); + cfs_spin_unlock(&page_pools.epp_lock); return rc; } @@ -239,21 +241,25 @@ static void enc_pools_release_free_pages(long npages) * could be called frequently for query (@nr_to_scan == 0). * we try to keep at least PTLRPC_MAX_BRW_PAGES pages in the pool. */ -static int enc_pools_shrink(int nr_to_scan, unsigned int gfp_mask) +static int enc_pools_shrink(SHRINKER_ARGS(sc, nr_to_scan, gfp_mask)) { - if (unlikely(nr_to_scan != 0)) { - spin_lock(&page_pools.epp_lock); - nr_to_scan = min(nr_to_scan, (int) page_pools.epp_free_pages - - PTLRPC_MAX_BRW_PAGES); - if (nr_to_scan > 0) { - enc_pools_release_free_pages(nr_to_scan); - CDEBUG(D_SEC, "released %d pages, %ld left\n", - nr_to_scan, page_pools.epp_free_pages); + if (unlikely(shrink_param(sc, nr_to_scan) != 0)) { + cfs_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 - + PTLRPC_MAX_BRW_PAGES); + if (shrink_param(sc, nr_to_scan) > 0) { + enc_pools_release_free_pages(shrink_param(sc, + nr_to_scan)); + CDEBUG(D_SEC, "released %ld pages, %ld left\n", + (long)shrink_param(sc, nr_to_scan), + page_pools.epp_free_pages); page_pools.epp_st_shrinks++; page_pools.epp_last_shrink = cfs_time_current_sec(); } - spin_unlock(&page_pools.epp_lock); + cfs_spin_unlock(&page_pools.epp_lock); } /* @@ -262,9 +268,9 @@ static int enc_pools_shrink(int nr_to_scan, unsigned int gfp_mask) */ if (unlikely(cfs_time_current_sec() - page_pools.epp_last_access > CACHE_QUIESCENT_PERIOD)) { - spin_lock(&page_pools.epp_lock); + cfs_spin_lock(&page_pools.epp_lock); page_pools.epp_idle_idx = IDLE_IDX_MAX; - spin_unlock(&page_pools.epp_lock); + cfs_spin_unlock(&page_pools.epp_lock); } LASSERT(page_pools.epp_idle_idx <= IDLE_IDX_MAX); @@ -320,7 +326,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); - spin_lock(&page_pools.epp_lock); + cfs_spin_lock(&page_pools.epp_lock); /* * (1) fill all the free slots of current pools. @@ -387,12 +393,12 @@ 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); - spin_unlock(&page_pools.epp_lock); + cfs_spin_unlock(&page_pools.epp_lock); } static int enc_pools_add_pages(int npages) { - static DECLARE_MUTEX(sem_add_pages); + static CFS_DECLARE_MUTEX(sem_add_pages); cfs_page_t ***pools; int npools, alloced = 0; int i, j, rc = -ENOMEM; @@ -400,7 +406,7 @@ static int enc_pools_add_pages(int npages) if (npages < PTLRPC_MAX_BRW_PAGES) npages = PTLRPC_MAX_BRW_PAGES; - down(&sem_add_pages); + cfs_down(&sem_add_pages); if (npages + page_pools.epp_total_pages > page_pools.epp_max_pages) npages = page_pools.epp_max_pages - page_pools.epp_total_pages; @@ -442,7 +448,7 @@ out: CERROR("Failed to allocate %d enc pages\n", npages); } - up(&sem_add_pages); + cfs_up(&sem_add_pages); return rc; } @@ -513,7 +519,7 @@ int sptlrpc_enc_pool_get_pages(struct ptlrpc_bulk_desc *desc) if (desc->bd_enc_iov == NULL) return -ENOMEM; - spin_lock(&page_pools.epp_lock); + cfs_spin_lock(&page_pools.epp_lock); page_pools.epp_st_access++; again: @@ -529,9 +535,9 @@ again: if (enc_pools_should_grow(desc->bd_iov_count, now)) { page_pools.epp_growing = 1; - spin_unlock(&page_pools.epp_lock); + cfs_spin_unlock(&page_pools.epp_lock); enc_pools_add_pages(page_pools.epp_pages_short / 2); - spin_lock(&page_pools.epp_lock); + cfs_spin_lock(&page_pools.epp_lock); page_pools.epp_growing = 0; @@ -542,15 +548,15 @@ again: page_pools.epp_st_max_wqlen = page_pools.epp_waitqlen; - set_current_state(CFS_TASK_UNINT); + cfs_set_current_state(CFS_TASK_UNINT); cfs_waitlink_init(&waitlink); cfs_waitq_add(&page_pools.epp_waitq, &waitlink); - spin_unlock(&page_pools.epp_lock); + 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); - spin_lock(&page_pools.epp_lock); + cfs_spin_lock(&page_pools.epp_lock); page_pools.epp_waitqlen--; } @@ -602,7 +608,7 @@ again: page_pools.epp_last_access = cfs_time_current_sec(); - spin_unlock(&page_pools.epp_lock); + cfs_spin_unlock(&page_pools.epp_lock); return 0; } EXPORT_SYMBOL(sptlrpc_enc_pool_get_pages); @@ -617,7 +623,7 @@ void sptlrpc_enc_pool_put_pages(struct ptlrpc_bulk_desc *desc) LASSERT(desc->bd_iov_count > 0); - spin_lock(&page_pools.epp_lock); + cfs_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; @@ -644,7 +650,7 @@ void sptlrpc_enc_pool_put_pages(struct ptlrpc_bulk_desc *desc) enc_pools_wakeup(); - spin_unlock(&page_pools.epp_lock); + cfs_spin_unlock(&page_pools.epp_lock); OBD_FREE(desc->bd_enc_iov, desc->bd_iov_count * sizeof(*desc->bd_enc_iov)); @@ -661,21 +667,21 @@ int sptlrpc_enc_pool_add_user(void) { int need_grow = 0; - spin_lock(&page_pools.epp_lock); + 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; } - spin_unlock(&page_pools.epp_lock); + cfs_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); + cfs_spin_lock(&page_pools.epp_lock); page_pools.epp_growing = 0; enc_pools_wakeup(); - spin_unlock(&page_pools.epp_lock); + cfs_spin_unlock(&page_pools.epp_lock); } return 0; } @@ -690,13 +696,9 @@ EXPORT_SYMBOL(sptlrpc_enc_pool_del_user); static inline void enc_pools_alloc(void) { LASSERT(page_pools.epp_max_pools); - /* - * on system with huge memory but small page size, this might lead to - * high-order allocation. but it's not common, and we suppose memory - * be not too much fragmented at module loading time. - */ - OBD_ALLOC(page_pools.epp_pools, - page_pools.epp_max_pools * sizeof(*page_pools.epp_pools)); + OBD_ALLOC_LARGE(page_pools.epp_pools, + page_pools.epp_max_pools * + sizeof(*page_pools.epp_pools)); } static inline void enc_pools_free(void) @@ -704,8 +706,9 @@ static inline void enc_pools_free(void) LASSERT(page_pools.epp_max_pools); LASSERT(page_pools.epp_pools); - OBD_FREE(page_pools.epp_pools, - page_pools.epp_max_pools * sizeof(*page_pools.epp_pools)); + OBD_FREE_LARGE(page_pools.epp_pools, + page_pools.epp_max_pools * + sizeof(*page_pools.epp_pools)); } int sptlrpc_enc_pool_init(void) @@ -714,7 +717,7 @@ int sptlrpc_enc_pool_init(void) * maximum capacity is 1/8 of total physical memory. * is the 1/8 a good number? */ - page_pools.epp_max_pages = num_physpages / 8; + page_pools.epp_max_pages = cfs_num_physpages / 8; page_pools.epp_max_pools = npages_to_npools(page_pools.epp_max_pages); cfs_waitq_init(&page_pools.epp_waitq); @@ -727,7 +730,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(); - spin_lock_init(&page_pools.epp_lock); + cfs_spin_lock_init(&page_pools.epp_lock); page_pools.epp_total_pages = 0; page_pools.epp_free_pages = 0; @@ -745,7 +748,8 @@ int sptlrpc_enc_pool_init(void) if (page_pools.epp_pools == NULL) return -ENOMEM; - pools_shrinker = set_shrinker(pools_shrinker_seeks, enc_pools_shrink); + pools_shrinker = cfs_set_shrinker(pools_shrinker_seeks, + enc_pools_shrink); if (pools_shrinker == NULL) { enc_pools_free(); return -ENOMEM; @@ -762,7 +766,7 @@ void sptlrpc_enc_pool_fini(void) LASSERT(page_pools.epp_pools); LASSERT(page_pools.epp_total_pages == page_pools.epp_free_pages); - remove_shrinker(pools_shrinker); + cfs_remove_shrinker(pools_shrinker); npools = npages_to_npools(page_pools.epp_total_pages); cleaned = enc_pools_cleanup(page_pools.epp_pools, npools); @@ -771,14 +775,15 @@ void sptlrpc_enc_pool_fini(void) enc_pools_free(); if (page_pools.epp_st_access > 0) { - CWARN("max pages %lu, grows %u, grow fails %u, shrinks %u, " - "access %lu, missing %lu, max qlen %u, max wait " - CFS_TIME_T"/%d\n", - page_pools.epp_st_max_pages, page_pools.epp_st_grows, - page_pools.epp_st_grow_fails, - page_pools.epp_st_shrinks, page_pools.epp_st_access, - page_pools.epp_st_missings, page_pools.epp_st_max_wqlen, - page_pools.epp_st_max_wait, HZ); + CDEBUG(D_SEC, + "max pages %lu, grows %u, grow fails %u, shrinks %u, " + "access %lu, missing %lu, max qlen %u, max wait " + CFS_TIME_T"/%d\n", + page_pools.epp_st_max_pages, page_pools.epp_st_grows, + page_pools.epp_st_grow_fails, + page_pools.epp_st_shrinks, page_pools.epp_st_access, + page_pools.epp_st_missings, page_pools.epp_st_max_wqlen, + page_pools.epp_st_max_wait, CFS_HZ); } }