4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
27 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
30 * Copyright (c) 2011, 2012, Intel Corporation.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
36 * lustre/ptlrpc/sec_bulk.c
38 * Author: Eric Mei <ericm@clusterfs.com>
41 #define DEBUG_SUBSYSTEM S_SEC
43 #include "../../include/linux/libcfs/libcfs.h"
44 #include <linux/crypto.h>
46 #include "../include/obd.h"
47 #include "../include/obd_cksum.h"
48 #include "../include/obd_class.h"
49 #include "../include/obd_support.h"
50 #include "../include/lustre_net.h"
51 #include "../include/lustre_import.h"
52 #include "../include/lustre_dlm.h"
53 #include "../include/lustre_sec.h"
55 #include "ptlrpc_internal.h"
57 /****************************************
58 * bulk encryption page pools *
59 ****************************************/
62 #define POINTERS_PER_PAGE (PAGE_CACHE_SIZE / sizeof(void *))
63 #define PAGES_PER_POOL (POINTERS_PER_PAGE)
65 #define IDLE_IDX_MAX (100)
66 #define IDLE_IDX_WEIGHT (3)
68 #define CACHE_QUIESCENT_PERIOD (20)
70 static struct ptlrpc_enc_page_pool
{
74 unsigned long epp_max_pages
; /* maximum pages can hold, const */
75 unsigned int epp_max_pools
; /* number of pools, const */
78 * wait queue in case of not enough free pages.
80 wait_queue_head_t epp_waitq
; /* waiting threads */
81 unsigned int epp_waitqlen
; /* wait queue length */
82 unsigned long epp_pages_short
; /* # of pages wanted of in-q users */
83 unsigned int epp_growing
:1; /* during adding pages */
86 * indicating how idle the pools are, from 0 to MAX_IDLE_IDX
87 * this is counted based on each time when getting pages from
88 * the pools, not based on time. which means in case that system
89 * is idled for a while but the idle_idx might still be low if no
90 * activities happened in the pools.
92 unsigned long epp_idle_idx
;
94 /* last shrink time due to mem tight */
99 * in-pool pages bookkeeping
101 spinlock_t epp_lock
; /* protect following fields */
102 unsigned long epp_total_pages
; /* total pages in pools */
103 unsigned long epp_free_pages
; /* current pages available */
108 unsigned long epp_st_max_pages
; /* # of pages ever reached */
109 unsigned int epp_st_grows
; /* # of grows */
110 unsigned int epp_st_grow_fails
; /* # of add pages failures */
111 unsigned int epp_st_shrinks
; /* # of shrinks */
112 unsigned long epp_st_access
; /* # of access */
113 unsigned long epp_st_missings
; /* # of cache missing */
114 unsigned long epp_st_lowfree
; /* lowest free pages reached */
115 unsigned int epp_st_max_wqlen
; /* highest waitqueue length */
116 unsigned long epp_st_max_wait
; /* in jiffies */
120 struct page
***epp_pools
;
124 * /proc/fs/lustre/sptlrpc/encrypt_page_pools
126 int sptlrpc_proc_enc_pool_seq_show(struct seq_file
*m
, void *v
)
128 spin_lock(&page_pools
.epp_lock
);
131 "physical pages: %lu\n"
132 "pages per pool: %lu\n"
137 "idle index: %lu/100\n"
138 "last shrink: %lds\n"
139 "last access: %lds\n"
140 "max pages reached: %lu\n"
142 "grows failure: %u\n"
144 "cache access: %lu\n"
145 "cache missing: %lu\n"
146 "low free mark: %lu\n"
147 "max waitqueue depth: %u\n"
148 "max wait time: " CFS_TIME_T
"/%u\n",
151 page_pools
.epp_max_pages
,
152 page_pools
.epp_max_pools
,
153 page_pools
.epp_total_pages
,
154 page_pools
.epp_free_pages
,
155 page_pools
.epp_idle_idx
,
156 get_seconds() - page_pools
.epp_last_shrink
,
157 get_seconds() - page_pools
.epp_last_access
,
158 page_pools
.epp_st_max_pages
,
159 page_pools
.epp_st_grows
,
160 page_pools
.epp_st_grow_fails
,
161 page_pools
.epp_st_shrinks
,
162 page_pools
.epp_st_access
,
163 page_pools
.epp_st_missings
,
164 page_pools
.epp_st_lowfree
,
165 page_pools
.epp_st_max_wqlen
,
166 page_pools
.epp_st_max_wait
,
169 spin_unlock(&page_pools
.epp_lock
);
174 static void enc_pools_release_free_pages(long npages
)
177 int p_idx_max1
, p_idx_max2
;
180 LASSERT(npages
<= page_pools
.epp_free_pages
);
181 LASSERT(page_pools
.epp_free_pages
<= page_pools
.epp_total_pages
);
183 /* max pool index before the release */
184 p_idx_max2
= (page_pools
.epp_total_pages
- 1) / PAGES_PER_POOL
;
186 page_pools
.epp_free_pages
-= npages
;
187 page_pools
.epp_total_pages
-= npages
;
189 /* max pool index after the release */
190 p_idx_max1
= page_pools
.epp_total_pages
== 0 ? -1 :
191 ((page_pools
.epp_total_pages
- 1) / PAGES_PER_POOL
);
193 p_idx
= page_pools
.epp_free_pages
/ PAGES_PER_POOL
;
194 g_idx
= page_pools
.epp_free_pages
% PAGES_PER_POOL
;
195 LASSERT(page_pools
.epp_pools
[p_idx
]);
198 LASSERT(page_pools
.epp_pools
[p_idx
]);
199 LASSERT(page_pools
.epp_pools
[p_idx
][g_idx
] != NULL
);
201 __free_page(page_pools
.epp_pools
[p_idx
][g_idx
]);
202 page_pools
.epp_pools
[p_idx
][g_idx
] = NULL
;
204 if (++g_idx
== PAGES_PER_POOL
) {
210 /* free unused pools */
211 while (p_idx_max1
< p_idx_max2
) {
212 LASSERT(page_pools
.epp_pools
[p_idx_max2
]);
213 kfree(page_pools
.epp_pools
[p_idx_max2
]);
214 page_pools
.epp_pools
[p_idx_max2
] = NULL
;
220 * we try to keep at least PTLRPC_MAX_BRW_PAGES pages in the pool.
222 static unsigned long enc_pools_shrink_count(struct shrinker
*s
,
223 struct shrink_control
*sc
)
226 * if no pool access for a long time, we consider it's fully idle.
227 * a little race here is fine.
229 if (unlikely(get_seconds() - page_pools
.epp_last_access
>
230 CACHE_QUIESCENT_PERIOD
)) {
231 spin_lock(&page_pools
.epp_lock
);
232 page_pools
.epp_idle_idx
= IDLE_IDX_MAX
;
233 spin_unlock(&page_pools
.epp_lock
);
236 LASSERT(page_pools
.epp_idle_idx
<= IDLE_IDX_MAX
);
237 return max((int)page_pools
.epp_free_pages
- PTLRPC_MAX_BRW_PAGES
, 0) *
238 (IDLE_IDX_MAX
- page_pools
.epp_idle_idx
) / IDLE_IDX_MAX
;
242 * we try to keep at least PTLRPC_MAX_BRW_PAGES pages in the pool.
244 static unsigned long enc_pools_shrink_scan(struct shrinker
*s
,
245 struct shrink_control
*sc
)
247 spin_lock(&page_pools
.epp_lock
);
248 sc
->nr_to_scan
= min_t(unsigned long, sc
->nr_to_scan
,
249 page_pools
.epp_free_pages
- PTLRPC_MAX_BRW_PAGES
);
250 if (sc
->nr_to_scan
> 0) {
251 enc_pools_release_free_pages(sc
->nr_to_scan
);
252 CDEBUG(D_SEC
, "released %ld pages, %ld left\n",
253 (long)sc
->nr_to_scan
, page_pools
.epp_free_pages
);
255 page_pools
.epp_st_shrinks
++;
256 page_pools
.epp_last_shrink
= get_seconds();
258 spin_unlock(&page_pools
.epp_lock
);
261 * if no pool access for a long time, we consider it's fully idle.
262 * a little race here is fine.
264 if (unlikely(get_seconds() - page_pools
.epp_last_access
>
265 CACHE_QUIESCENT_PERIOD
)) {
266 spin_lock(&page_pools
.epp_lock
);
267 page_pools
.epp_idle_idx
= IDLE_IDX_MAX
;
268 spin_unlock(&page_pools
.epp_lock
);
271 LASSERT(page_pools
.epp_idle_idx
<= IDLE_IDX_MAX
);
272 return sc
->nr_to_scan
;
276 int npages_to_npools(unsigned long npages
)
278 return (int) ((npages
+ PAGES_PER_POOL
- 1) / PAGES_PER_POOL
);
282 * return how many pages cleaned up.
284 static unsigned long enc_pools_cleanup(struct page
***pools
, int npools
)
286 unsigned long cleaned
= 0;
289 for (i
= 0; i
< npools
; i
++) {
291 for (j
= 0; j
< PAGES_PER_POOL
; j
++) {
293 __free_page(pools
[i
][j
]);
306 * merge @npools pointed by @pools which contains @npages new pages
307 * into current pools.
309 * we have options to avoid most memory copy with some tricks. but we choose
310 * the simplest way to avoid complexity. It's not frequently called.
312 static void enc_pools_insert(struct page
***pools
, int npools
, int npages
)
315 int op_idx
, np_idx
, og_idx
, ng_idx
;
316 int cur_npools
, end_npools
;
319 LASSERT(page_pools
.epp_total_pages
+npages
<= page_pools
.epp_max_pages
);
320 LASSERT(npages_to_npools(npages
) == npools
);
321 LASSERT(page_pools
.epp_growing
);
323 spin_lock(&page_pools
.epp_lock
);
326 * (1) fill all the free slots of current pools.
328 /* free slots are those left by rent pages, and the extra ones with
329 * index >= total_pages, locate at the tail of last pool. */
330 freeslot
= page_pools
.epp_total_pages
% PAGES_PER_POOL
;
332 freeslot
= PAGES_PER_POOL
- freeslot
;
333 freeslot
+= page_pools
.epp_total_pages
- page_pools
.epp_free_pages
;
335 op_idx
= page_pools
.epp_free_pages
/ PAGES_PER_POOL
;
336 og_idx
= page_pools
.epp_free_pages
% PAGES_PER_POOL
;
338 ng_idx
= (npages
- 1) % PAGES_PER_POOL
;
341 LASSERT(page_pools
.epp_pools
[op_idx
][og_idx
] == NULL
);
342 LASSERT(pools
[np_idx
][ng_idx
] != NULL
);
344 page_pools
.epp_pools
[op_idx
][og_idx
] = pools
[np_idx
][ng_idx
];
345 pools
[np_idx
][ng_idx
] = NULL
;
349 if (++og_idx
== PAGES_PER_POOL
) {
357 ng_idx
= PAGES_PER_POOL
- 1;
362 * (2) add pools if needed.
364 cur_npools
= (page_pools
.epp_total_pages
+ PAGES_PER_POOL
- 1) /
366 end_npools
= (page_pools
.epp_total_pages
+ npages
+ PAGES_PER_POOL
- 1)
368 LASSERT(end_npools
<= page_pools
.epp_max_pools
);
371 while (cur_npools
< end_npools
) {
372 LASSERT(page_pools
.epp_pools
[cur_npools
] == NULL
);
373 LASSERT(np_idx
< npools
);
374 LASSERT(pools
[np_idx
] != NULL
);
376 page_pools
.epp_pools
[cur_npools
++] = pools
[np_idx
];
377 pools
[np_idx
++] = NULL
;
380 page_pools
.epp_total_pages
+= npages
;
381 page_pools
.epp_free_pages
+= npages
;
382 page_pools
.epp_st_lowfree
= page_pools
.epp_free_pages
;
384 if (page_pools
.epp_total_pages
> page_pools
.epp_st_max_pages
)
385 page_pools
.epp_st_max_pages
= page_pools
.epp_total_pages
;
387 CDEBUG(D_SEC
, "add %d pages to total %lu\n", npages
,
388 page_pools
.epp_total_pages
);
390 spin_unlock(&page_pools
.epp_lock
);
393 static int enc_pools_add_pages(int npages
)
395 static DEFINE_MUTEX(add_pages_mutex
);
396 struct page
***pools
;
397 int npools
, alloced
= 0;
398 int i
, j
, rc
= -ENOMEM
;
400 if (npages
< PTLRPC_MAX_BRW_PAGES
)
401 npages
= PTLRPC_MAX_BRW_PAGES
;
403 mutex_lock(&add_pages_mutex
);
405 if (npages
+ page_pools
.epp_total_pages
> page_pools
.epp_max_pages
)
406 npages
= page_pools
.epp_max_pages
- page_pools
.epp_total_pages
;
409 page_pools
.epp_st_grows
++;
411 npools
= npages_to_npools(npages
);
412 pools
= kcalloc(npools
, sizeof(*pools
), GFP_NOFS
);
416 for (i
= 0; i
< npools
; i
++) {
417 pools
[i
] = kzalloc(PAGE_CACHE_SIZE
, GFP_NOFS
);
421 for (j
= 0; j
< PAGES_PER_POOL
&& alloced
< npages
; j
++) {
422 pools
[i
][j
] = alloc_page(GFP_NOFS
|
424 if (pools
[i
][j
] == NULL
)
430 LASSERT(alloced
== npages
);
432 enc_pools_insert(pools
, npools
, npages
);
433 CDEBUG(D_SEC
, "added %d pages into pools\n", npages
);
437 enc_pools_cleanup(pools
, npools
);
441 page_pools
.epp_st_grow_fails
++;
442 CERROR("Failed to allocate %d enc pages\n", npages
);
445 mutex_unlock(&add_pages_mutex
);
449 static inline void enc_pools_wakeup(void)
451 assert_spin_locked(&page_pools
.epp_lock
);
452 LASSERT(page_pools
.epp_waitqlen
>= 0);
454 if (unlikely(page_pools
.epp_waitqlen
)) {
455 LASSERT(waitqueue_active(&page_pools
.epp_waitq
));
456 wake_up_all(&page_pools
.epp_waitq
);
460 static int enc_pools_should_grow(int page_needed
, long now
)
462 /* don't grow if someone else is growing the pools right now,
463 * or the pools has reached its full capacity
465 if (page_pools
.epp_growing
||
466 page_pools
.epp_total_pages
== page_pools
.epp_max_pages
)
469 /* if total pages is not enough, we need to grow */
470 if (page_pools
.epp_total_pages
< page_needed
)
474 * we wanted to return 0 here if there was a shrink just happened
475 * moment ago, but this may cause deadlock if both client and ost
476 * live on single node.
479 if (now
- page_pools
.epp_last_shrink
< 2)
484 * here we perhaps need consider other factors like wait queue
485 * length, idle index, etc. ?
488 /* grow the pools in any other cases */
493 * we allocate the requested pages atomically.
495 int sptlrpc_enc_pool_get_pages(struct ptlrpc_bulk_desc
*desc
)
497 wait_queue_t waitlink
;
498 unsigned long this_idle
= -1;
499 unsigned long tick
= 0;
504 LASSERT(desc
->bd_iov_count
> 0);
505 LASSERT(desc
->bd_iov_count
<= page_pools
.epp_max_pages
);
507 /* resent bulk, enc iov might have been allocated previously */
508 if (desc
->bd_enc_iov
!= NULL
)
511 desc
->bd_enc_iov
= kcalloc(desc
->bd_iov_count
,
512 sizeof(*desc
->bd_enc_iov
), GFP_NOFS
);
513 if (desc
->bd_enc_iov
== NULL
)
516 spin_lock(&page_pools
.epp_lock
);
518 page_pools
.epp_st_access
++;
520 if (unlikely(page_pools
.epp_free_pages
< desc
->bd_iov_count
)) {
522 tick
= cfs_time_current();
526 page_pools
.epp_st_missings
++;
527 page_pools
.epp_pages_short
+= desc
->bd_iov_count
;
529 if (enc_pools_should_grow(desc
->bd_iov_count
, now
)) {
530 page_pools
.epp_growing
= 1;
532 spin_unlock(&page_pools
.epp_lock
);
533 enc_pools_add_pages(page_pools
.epp_pages_short
/ 2);
534 spin_lock(&page_pools
.epp_lock
);
536 page_pools
.epp_growing
= 0;
540 if (++page_pools
.epp_waitqlen
>
541 page_pools
.epp_st_max_wqlen
)
542 page_pools
.epp_st_max_wqlen
=
543 page_pools
.epp_waitqlen
;
545 set_current_state(TASK_UNINTERRUPTIBLE
);
546 init_waitqueue_entry(&waitlink
, current
);
547 add_wait_queue(&page_pools
.epp_waitq
, &waitlink
);
549 spin_unlock(&page_pools
.epp_lock
);
551 remove_wait_queue(&page_pools
.epp_waitq
, &waitlink
);
552 LASSERT(page_pools
.epp_waitqlen
> 0);
553 spin_lock(&page_pools
.epp_lock
);
554 page_pools
.epp_waitqlen
--;
557 LASSERT(page_pools
.epp_pages_short
>= desc
->bd_iov_count
);
558 page_pools
.epp_pages_short
-= desc
->bd_iov_count
;
564 /* record max wait time */
565 if (unlikely(tick
!= 0)) {
566 tick
= cfs_time_current() - tick
;
567 if (tick
> page_pools
.epp_st_max_wait
)
568 page_pools
.epp_st_max_wait
= tick
;
571 /* proceed with rest of allocation */
572 page_pools
.epp_free_pages
-= desc
->bd_iov_count
;
574 p_idx
= page_pools
.epp_free_pages
/ PAGES_PER_POOL
;
575 g_idx
= page_pools
.epp_free_pages
% PAGES_PER_POOL
;
577 for (i
= 0; i
< desc
->bd_iov_count
; i
++) {
578 LASSERT(page_pools
.epp_pools
[p_idx
][g_idx
] != NULL
);
579 desc
->bd_enc_iov
[i
].kiov_page
=
580 page_pools
.epp_pools
[p_idx
][g_idx
];
581 page_pools
.epp_pools
[p_idx
][g_idx
] = NULL
;
583 if (++g_idx
== PAGES_PER_POOL
) {
589 if (page_pools
.epp_free_pages
< page_pools
.epp_st_lowfree
)
590 page_pools
.epp_st_lowfree
= page_pools
.epp_free_pages
;
593 * new idle index = (old * weight + new) / (weight + 1)
595 if (this_idle
== -1) {
596 this_idle
= page_pools
.epp_free_pages
* IDLE_IDX_MAX
/
597 page_pools
.epp_total_pages
;
599 page_pools
.epp_idle_idx
= (page_pools
.epp_idle_idx
* IDLE_IDX_WEIGHT
+
601 (IDLE_IDX_WEIGHT
+ 1);
603 page_pools
.epp_last_access
= get_seconds();
605 spin_unlock(&page_pools
.epp_lock
);
608 EXPORT_SYMBOL(sptlrpc_enc_pool_get_pages
);
610 void sptlrpc_enc_pool_put_pages(struct ptlrpc_bulk_desc
*desc
)
615 if (desc
->bd_enc_iov
== NULL
)
618 LASSERT(desc
->bd_iov_count
> 0);
620 spin_lock(&page_pools
.epp_lock
);
622 p_idx
= page_pools
.epp_free_pages
/ PAGES_PER_POOL
;
623 g_idx
= page_pools
.epp_free_pages
% PAGES_PER_POOL
;
625 LASSERT(page_pools
.epp_free_pages
+ desc
->bd_iov_count
<=
626 page_pools
.epp_total_pages
);
627 LASSERT(page_pools
.epp_pools
[p_idx
]);
629 for (i
= 0; i
< desc
->bd_iov_count
; i
++) {
630 LASSERT(desc
->bd_enc_iov
[i
].kiov_page
!= NULL
);
631 LASSERT(g_idx
!= 0 || page_pools
.epp_pools
[p_idx
]);
632 LASSERT(page_pools
.epp_pools
[p_idx
][g_idx
] == NULL
);
634 page_pools
.epp_pools
[p_idx
][g_idx
] =
635 desc
->bd_enc_iov
[i
].kiov_page
;
637 if (++g_idx
== PAGES_PER_POOL
) {
643 page_pools
.epp_free_pages
+= desc
->bd_iov_count
;
647 spin_unlock(&page_pools
.epp_lock
);
649 kfree(desc
->bd_enc_iov
);
650 desc
->bd_enc_iov
= NULL
;
652 EXPORT_SYMBOL(sptlrpc_enc_pool_put_pages
);
655 * we don't do much stuff for add_user/del_user anymore, except adding some
656 * initial pages in add_user() if current pools are empty, rest would be
657 * handled by the pools's self-adaption.
659 int sptlrpc_enc_pool_add_user(void)
663 spin_lock(&page_pools
.epp_lock
);
664 if (page_pools
.epp_growing
== 0 && page_pools
.epp_total_pages
== 0) {
665 page_pools
.epp_growing
= 1;
668 spin_unlock(&page_pools
.epp_lock
);
671 enc_pools_add_pages(PTLRPC_MAX_BRW_PAGES
+
672 PTLRPC_MAX_BRW_PAGES
);
674 spin_lock(&page_pools
.epp_lock
);
675 page_pools
.epp_growing
= 0;
677 spin_unlock(&page_pools
.epp_lock
);
681 EXPORT_SYMBOL(sptlrpc_enc_pool_add_user
);
683 int sptlrpc_enc_pool_del_user(void)
687 EXPORT_SYMBOL(sptlrpc_enc_pool_del_user
);
689 static inline void enc_pools_alloc(void)
691 LASSERT(page_pools
.epp_max_pools
);
692 page_pools
.epp_pools
=
693 libcfs_kvzalloc(page_pools
.epp_max_pools
*
694 sizeof(*page_pools
.epp_pools
),
698 static inline void enc_pools_free(void)
700 LASSERT(page_pools
.epp_max_pools
);
701 LASSERT(page_pools
.epp_pools
);
703 kvfree(page_pools
.epp_pools
);
706 static struct shrinker pools_shrinker
= {
707 .count_objects
= enc_pools_shrink_count
,
708 .scan_objects
= enc_pools_shrink_scan
,
709 .seeks
= DEFAULT_SEEKS
,
712 int sptlrpc_enc_pool_init(void)
715 * maximum capacity is 1/8 of total physical memory.
716 * is the 1/8 a good number?
718 page_pools
.epp_max_pages
= totalram_pages
/ 8;
719 page_pools
.epp_max_pools
= npages_to_npools(page_pools
.epp_max_pages
);
721 init_waitqueue_head(&page_pools
.epp_waitq
);
722 page_pools
.epp_waitqlen
= 0;
723 page_pools
.epp_pages_short
= 0;
725 page_pools
.epp_growing
= 0;
727 page_pools
.epp_idle_idx
= 0;
728 page_pools
.epp_last_shrink
= get_seconds();
729 page_pools
.epp_last_access
= get_seconds();
731 spin_lock_init(&page_pools
.epp_lock
);
732 page_pools
.epp_total_pages
= 0;
733 page_pools
.epp_free_pages
= 0;
735 page_pools
.epp_st_max_pages
= 0;
736 page_pools
.epp_st_grows
= 0;
737 page_pools
.epp_st_grow_fails
= 0;
738 page_pools
.epp_st_shrinks
= 0;
739 page_pools
.epp_st_access
= 0;
740 page_pools
.epp_st_missings
= 0;
741 page_pools
.epp_st_lowfree
= 0;
742 page_pools
.epp_st_max_wqlen
= 0;
743 page_pools
.epp_st_max_wait
= 0;
746 if (page_pools
.epp_pools
== NULL
)
749 register_shrinker(&pools_shrinker
);
754 void sptlrpc_enc_pool_fini(void)
756 unsigned long cleaned
, npools
;
758 LASSERT(page_pools
.epp_pools
);
759 LASSERT(page_pools
.epp_total_pages
== page_pools
.epp_free_pages
);
761 unregister_shrinker(&pools_shrinker
);
763 npools
= npages_to_npools(page_pools
.epp_total_pages
);
764 cleaned
= enc_pools_cleanup(page_pools
.epp_pools
, npools
);
765 LASSERT(cleaned
== page_pools
.epp_total_pages
);
769 if (page_pools
.epp_st_access
> 0) {
771 "max pages %lu, grows %u, grow fails %u, shrinks %u, access %lu, missing %lu, max qlen %u, max wait "
773 page_pools
.epp_st_max_pages
, page_pools
.epp_st_grows
,
774 page_pools
.epp_st_grow_fails
,
775 page_pools
.epp_st_shrinks
, page_pools
.epp_st_access
,
776 page_pools
.epp_st_missings
, page_pools
.epp_st_max_wqlen
,
777 page_pools
.epp_st_max_wait
, HZ
);
782 static int cfs_hash_alg_id
[] = {
783 [BULK_HASH_ALG_NULL
] = CFS_HASH_ALG_NULL
,
784 [BULK_HASH_ALG_ADLER32
] = CFS_HASH_ALG_ADLER32
,
785 [BULK_HASH_ALG_CRC32
] = CFS_HASH_ALG_CRC32
,
786 [BULK_HASH_ALG_MD5
] = CFS_HASH_ALG_MD5
,
787 [BULK_HASH_ALG_SHA1
] = CFS_HASH_ALG_SHA1
,
788 [BULK_HASH_ALG_SHA256
] = CFS_HASH_ALG_SHA256
,
789 [BULK_HASH_ALG_SHA384
] = CFS_HASH_ALG_SHA384
,
790 [BULK_HASH_ALG_SHA512
] = CFS_HASH_ALG_SHA512
,
792 const char *sptlrpc_get_hash_name(__u8 hash_alg
)
794 return cfs_crypto_hash_name(cfs_hash_alg_id
[hash_alg
]);
796 EXPORT_SYMBOL(sptlrpc_get_hash_name
);
798 __u8
sptlrpc_get_hash_alg(const char *algname
)
800 return cfs_crypto_hash_alg(algname
);
802 EXPORT_SYMBOL(sptlrpc_get_hash_alg
);
804 int bulk_sec_desc_unpack(struct lustre_msg
*msg
, int offset
, int swabbed
)
806 struct ptlrpc_bulk_sec_desc
*bsd
;
807 int size
= msg
->lm_buflens
[offset
];
809 bsd
= lustre_msg_buf(msg
, offset
, sizeof(*bsd
));
811 CERROR("Invalid bulk sec desc: size %d\n", size
);
816 __swab32s(&bsd
->bsd_nob
);
818 if (unlikely(bsd
->bsd_version
!= 0)) {
819 CERROR("Unexpected version %u\n", bsd
->bsd_version
);
823 if (unlikely(bsd
->bsd_type
>= SPTLRPC_BULK_MAX
)) {
824 CERROR("Invalid type %u\n", bsd
->bsd_type
);
828 /* FIXME more sanity check here */
830 if (unlikely(bsd
->bsd_svc
!= SPTLRPC_BULK_SVC_NULL
&&
831 bsd
->bsd_svc
!= SPTLRPC_BULK_SVC_INTG
&&
832 bsd
->bsd_svc
!= SPTLRPC_BULK_SVC_PRIV
)) {
833 CERROR("Invalid svc %u\n", bsd
->bsd_svc
);
839 EXPORT_SYMBOL(bulk_sec_desc_unpack
);
841 int sptlrpc_get_bulk_checksum(struct ptlrpc_bulk_desc
*desc
, __u8 alg
,
842 void *buf
, int buflen
)
844 struct cfs_crypto_hash_desc
*hdesc
;
847 unsigned int bufsize
;
850 LASSERT(alg
> BULK_HASH_ALG_NULL
&& alg
< BULK_HASH_ALG_MAX
);
851 LASSERT(buflen
>= 4);
853 hdesc
= cfs_crypto_hash_init(cfs_hash_alg_id
[alg
], NULL
, 0);
855 CERROR("Unable to initialize checksum hash %s\n",
856 cfs_crypto_hash_name(cfs_hash_alg_id
[alg
]));
857 return PTR_ERR(hdesc
);
860 hashsize
= cfs_crypto_hash_digestsize(cfs_hash_alg_id
[alg
]);
862 for (i
= 0; i
< desc
->bd_iov_count
; i
++) {
863 cfs_crypto_hash_update_page(hdesc
, desc
->bd_iov
[i
].kiov_page
,
864 desc
->bd_iov
[i
].kiov_offset
& ~CFS_PAGE_MASK
,
865 desc
->bd_iov
[i
].kiov_len
);
867 if (hashsize
> buflen
) {
868 bufsize
= sizeof(hashbuf
);
869 err
= cfs_crypto_hash_final(hdesc
, (unsigned char *)hashbuf
,
871 memcpy(buf
, hashbuf
, buflen
);
874 err
= cfs_crypto_hash_final(hdesc
, (unsigned char *)buf
,
879 cfs_crypto_hash_final(hdesc
, NULL
, NULL
);
882 EXPORT_SYMBOL(sptlrpc_get_bulk_checksum
);