From 8383ca063d2473a87e585c20d80138d68d7d4dbf Mon Sep 17 00:00:00 2001 From: Nikos Mavrogiannopoulos Date: Fri, 23 Jul 2010 08:27:58 +0200 Subject: Revert "Modified NCR-USER API to "simplify" and allow setting of size of data structure without special system call." This reverts commit 5689c9734223fb349bba526d620823a803c3b67e. --- .gitignore | 1 - examples/Makefile | 4 - examples/ncr-user.c | 930 ---------------------------------------------------- examples/ncr.c | 11 +- examples/pk.c | 7 + ncr-data.c | 188 +++-------- ncr-key-wrap.c | 44 +-- ncr-key.c | 36 +- ncr-sessions.c | 89 +---- ncr.c | 2 - ncr.h | 16 +- ncr_int.h | 19 +- 12 files changed, 105 insertions(+), 1242 deletions(-) delete mode 100644 examples/ncr-user.c diff --git a/.gitignore b/.gitignore index 6728db5..4379d92 100644 --- a/.gitignore +++ b/.gitignore @@ -10,7 +10,6 @@ modules.order examples/cipher examples/hmac examples/ncr -examples/ncr-user examples/pk examples/speed releases diff --git a/examples/Makefile b/examples/Makefile index a2849d3..c65297f 100644 --- a/examples/Makefile +++ b/examples/Makefile @@ -17,15 +17,11 @@ hmac: hmac.c ncr: ncr.c $(CC) $(CFLAGS) $< -o $@ -ncr-user: ncr-user.c - $(CC) $(CFLAGS) $< -o $@ - pk: pk.c $(CC) $(CFLAGS) $< -o $@ -L/usr/local/lib -lgnutls check: $(progs) ./ncr - ./ncr-user ./pk ./cipher ./hmac diff --git a/examples/ncr-user.c b/examples/ncr-user.c deleted file mode 100644 index 613f81c..0000000 --- a/examples/ncr-user.c +++ /dev/null @@ -1,930 +0,0 @@ -/* - * Demo on how to use /dev/crypto device for HMAC. - * - * Placed under public domain. - * - */ -#include -#include -#include -#include -#include -#include -#include -#include -#include "../ncr.h" -#include - -#define DATA_SIZE 4096 - -static void randomize_data(uint8_t * data, size_t data_size) -{ -int i; - - srand(time(0)*getpid()); - for (i=0;irefcnt)) { ncr_limits_remove(item->uid, item->pid, LIMIT_TYPE_DATA); if (item->type == NCR_DATA_KERNEL) - kfree(item->data.kernel.data); + kfree(item->data.kernel); else if (item->type == NCR_DATA_USER) ncr_data_item_put_sg(item); /* just in case */ kfree(item); @@ -115,25 +115,16 @@ int ncr_data_item_get_sg( struct data_item_st* item, struct scatterlist** sg, if (item->type == NCR_DATA_KERNEL) { item->flags = data_flags; - sg_init_one(item->_sg, item->data.kernel.data, item->data.kernel.max_data_size); + sg_init_one(item->_sg, item->data.kernel, item->max_data_size); - if (data_size) *data_size = item->data.kernel.data_size; - if (max_data_size) *max_data_size = item->data.kernel.max_data_size; + if (data_size) *data_size = item->data_size; + if (max_data_size) *max_data_size = item->max_data_size; *sg_cnt = 1; *sg = item->_sg; } else if (item->type == NCR_DATA_USER) { int ret; - size_t pagecount, item_size; - - ret = ncr_data_item_size(item, 0); - if (ret < 0) { - err(); - return ret; - } - item_size = ret; - - pagecount = PAGECOUNT(item->data.user.ptr, item_size); + size_t pagecount = PAGECOUNT(item->data.user.ptr, item->data_size); if (atomic_add_unless(&item->data.user.pg_used, 1, 1) == 0) { err(); @@ -150,15 +141,15 @@ int ncr_data_item_get_sg( struct data_item_st* item, struct scatterlist** sg, return -EOVERFLOW; } - ret = __get_userbuf(item->data.user.ptr, item_size, write, + ret = __get_userbuf(item->data.user.ptr, item->data_size, write, pagecount, item->data.user.pg, item->_sg); if (ret < 0) { err(); return ret; } - if (max_data_size) *max_data_size = item_size; - if (data_size) *data_size = item_size; + if (max_data_size) *max_data_size = item->data_size; + if (data_size) *data_size = item->data_size; *sg = item->_sg; *sg_cnt = item->data.user.pg_cnt = pagecount; } else { @@ -182,45 +173,6 @@ void ncr_data_item_put_sg( struct data_item_st* item) return; } -int ncr_data_item_set_size( struct data_item_st* item, size_t new_size) -{ - switch(item->type) { - case NCR_DATA_KERNEL: - item->data.kernel.data_size = new_size; - - return 0; - case NCR_DATA_USER: - if (unlikely(copy_to_user(item->data.user.size_ptr, &new_size, sizeof(new_size)))) { - err(); - return -EFAULT; - } - return 0; - default: - return -EINVAL; - } -} - -int ncr_data_item_size( struct data_item_st* item, int max) -{ -size_t size; - - switch(item->type) { - case NCR_DATA_KERNEL: - if (max == 0) - return item->data.kernel.data_size; - else - return item->data.kernel.max_data_size; - case NCR_DATA_USER: - if (unlikely(copy_from_user(&size, item->data.user.size_ptr, sizeof(size)))) { - err(); - return -EFAULT; - } - return size; - default: - return -EINVAL; - } -} - int ncr_data_item_setd( struct data_item_st* item, const void* data, size_t data_size, unsigned int data_flags) { struct scatterlist* sg; @@ -246,12 +198,7 @@ int ret; ret = -EINVAL; goto fail; } - - ret = ncr_data_item_set_size( item, data_size); - if (ret < 0) { - err(); - goto fail; - } + item->data_size = data_size; ret = 0; fail: @@ -324,92 +271,35 @@ int ncr_data_init(struct list_sem_st* lst, void __user* arg) atomic_set(&data->refcnt, 1); - data->type = NCR_DATA_KERNEL; + data->type = init.type; - data->data.kernel.data = data_alloc(init.max_object_size); - if (data->data.kernel.data == NULL) { - err(); - ret = -ENOMEM; - goto err_data; - } - data->data.kernel.max_data_size = init.max_object_size; - - if (init.initial_data != NULL) { - if (unlikely(copy_from_user(data->data.kernel.data, init.initial_data, - init.initial_data_size))) { + if (init.type == NCR_DATA_KERNEL) { + data->data.kernel = data_alloc(init.max_object_size); + if (data->data.kernel == NULL) { err(); - _ncr_data_item_put(data); - return -EFAULT; + ret = -ENOMEM; + goto err_data; } - data->data.kernel.data_size = init.initial_data_size; - } - - down(&lst->sem); - - data->desc = _ncr_data_get_new_desc(lst); - - list_add(&data->list, &lst->list); - - up(&lst->sem); - - init.desc = data->desc; - ret = copy_to_user(arg, &init, sizeof(init)); - if (unlikely(ret)) { - down(&lst->sem); - _ncr_data_unlink_item(data); - up(&lst->sem); - return -EFAULT; - } - return ret; + data->max_data_size = init.max_object_size; - err_data: - kfree(data); - err_limits: - ncr_limits_remove(current_euid(), task_pid_nr(current), - LIMIT_TYPE_DATA); - return ret; -} - -int ncr_data_init_user(struct list_sem_st* lst, void __user* arg) -{ - struct ncr_data_init_user_st init; - struct data_item_st* data; - int ret; - - ret = ncr_limits_add_and_check(current_euid(), task_pid_nr(current), LIMIT_TYPE_DATA); - if (ret < 0) { - err(); - return ret; - } - - if (unlikely(copy_from_user(&init, arg, sizeof(init)))) { - err(); - ret = -EFAULT; - goto err_limits; - } - - data = kmalloc(sizeof(*data), GFP_KERNEL); - if (data == NULL) { + if (init.initial_data != NULL) { + if (unlikely(copy_from_user(data->data.kernel, init.initial_data, + init.initial_data_size))) { + err(); + _ncr_data_item_put(data); + return -EFAULT; + } + data->data_size = init.initial_data_size; + } + } else if (init.type == NCR_DATA_USER) { + data->data.user.ptr = init.initial_data; + data->max_data_size = data->data_size = init.initial_data_size; + atomic_set(&data->data.user.pg_used, 0); + } else { err(); - ret = -ENOMEM; - goto err_limits; + goto err_data; } - memset(data, 0, sizeof(*data)); - - data->flags = init.flags; - data->uid = current_euid(); - data->pid = task_pid_nr(current); - - atomic_set(&data->refcnt, 1); - - data->type = NCR_DATA_USER; - - data->data.user.ptr = init.data; - data->data.user.size_ptr = init.data_size_ptr; - - atomic_set(&data->data.user.pg_used, 0); - down(&lst->sem); data->desc = _ncr_data_get_new_desc(lst); @@ -428,6 +318,8 @@ int ncr_data_init_user(struct list_sem_st* lst, void __user* arg) } return ret; + err_data: + kfree(data); err_limits: ncr_limits_remove(current_euid(), task_pid_nr(current), LIMIT_TYPE_DATA); @@ -476,7 +368,7 @@ int ncr_data_get(struct list_sem_st* lst, void __user* arg) return -EINVAL; } - if (data->type != NCR_DATA_KERNEL) { + if (data->type == NCR_DATA_USER) { err(); ret = -EINVAL; goto cleanup; @@ -488,7 +380,7 @@ int ncr_data_get(struct list_sem_st* lst, void __user* arg) goto cleanup; } - len = min(get.data_size, data->data.kernel.data_size); + len = min(get.data_size, data->data_size); /* update length */ get.data_size = len; @@ -499,7 +391,7 @@ int ncr_data_get(struct list_sem_st* lst, void __user* arg) } if (ret == 0 && len > 0) { - ret = copy_to_user(get.data, data->data.kernel.data, len); + ret = copy_to_user(get.data, data->data.kernel, len); if (unlikely(ret)) { err(); ret = -EFAULT; @@ -529,13 +421,13 @@ int ncr_data_set(struct list_sem_st* lst, void __user* arg) return -EINVAL; } - if (data->type != NCR_DATA_KERNEL) { + if (data->type == NCR_DATA_USER) { err(); ret = -EINVAL; goto cleanup; } - if ((get.data_size > data->data.kernel.max_data_size) || + if ((get.data_size > data->max_data_size) || (get.data == NULL && get.data_size != 0)) { err(); ret = -EINVAL; @@ -543,14 +435,14 @@ int ncr_data_set(struct list_sem_st* lst, void __user* arg) } if (get.data != NULL) { - if (unlikely(copy_from_user(data->data.kernel.data, get.data, + if (unlikely(copy_from_user(data->data.kernel, get.data, get.data_size))) { err(); ret = -EFAULT; goto cleanup; } } - data->data.kernel.data_size = get.data_size; + data->data_size = get.data_size; ret = 0; diff --git a/ncr-key-wrap.c b/ncr-key-wrap.c index 67fe10d..d38edca 100644 --- a/ncr-key-wrap.c +++ b/ncr-key-wrap.c @@ -51,17 +51,8 @@ uint8_t aes_block[16]; int i,j, ret; uint8_t * output; size_t output_size = (n+1)*8; -size_t max_data_size; - ret = ncr_data_item_size(odata, 1); - if (ret < 0) { - err(); - return ret; - } - max_data_size = ret; - - - if (max_data_size < output_size) { + if (odata->max_data_size < output_size) { err(); return -EINVAL; } @@ -202,14 +193,6 @@ struct cipher_data ctx; uint8_t iv[4]; size_t size; - ret = ncr_data_item_size(wrapped, 0); - if (ret < 0) { - err(); - return ret; - } - wrapped_key_size = ret; - - if (iv_size != 4) { memcpy(iv, RFC5649_IV, 4); } else { @@ -223,16 +206,16 @@ size_t size; return ret; } - wrapped_key = kmalloc(wrapped_key_size, GFP_KERNEL); + wrapped_key = kmalloc(wrapped->data_size, GFP_KERNEL); if (wrapped_key == NULL) { err(); ret = -ENOMEM; goto cleanup; } + wrapped_key_size = wrapped->data_size; - - ret = ncr_data_item_getd( wrapped, wrapped_key, wrapped_key_size, wrapped->flags); + ret = ncr_data_item_getd( wrapped, wrapped_key, wrapped->data_size, wrapped->flags); if (ret < 0) { err(); goto cleanup; @@ -407,13 +390,6 @@ val64_t A; int i, ret; struct cipher_data ctx; - ret = ncr_data_item_size(wrapped, 0); - if (ret < 0) { - err(); - return ret; - } - wrapped_key_size = ret; - if (iv_size < sizeof(initA)) { iv_size = sizeof(initA); iv = initA; @@ -427,13 +403,15 @@ struct cipher_data ctx; output->type = NCR_KEY_TYPE_SECRET; - wrapped_key = kmalloc(wrapped_key_size, GFP_KERNEL); + wrapped_key = kmalloc(wrapped->data_size, GFP_KERNEL); if (wrapped_key == NULL) { err(); ret = -ENOMEM; goto cleanup; } + wrapped_key_size = wrapped->data_size; + ret = ncr_data_item_getd( wrapped, wrapped_key, wrapped_key_size, wrapped->flags); if (ret < 0) { err(); @@ -696,13 +674,7 @@ int ret; goto fail; } - ret = ncr_data_item_size(data, 0); - if (ret < 0) { - err(); - return ret; - } - sdata_size = ret; - + sdata_size = data->data_size; sdata = kmalloc(sdata_size, GFP_KERNEL); if (sdata == NULL) { err(); diff --git a/ncr-key.c b/ncr-key.c index 18cb387..c6ce932 100644 --- a/ncr-key.c +++ b/ncr-key.c @@ -241,7 +241,6 @@ uint32_t size; uint32_t data_flags; int ret; uint8_t* tmp = NULL; -size_t max_data_size; if (unlikely(copy_from_user(&data, arg, sizeof(data)))) { err(); @@ -263,16 +262,9 @@ size_t max_data_size; data_flags = key_flags_to_data(item->flags); - ret = ncr_data_item_size(ditem, 1); - if (ret < 0) { - err(); - goto fail; - } - max_data_size = ret; - switch (item->type) { case NCR_KEY_TYPE_SECRET: - if (item->key.secret.size > max_data_size) { + if (item->key.secret.size > ditem->max_data_size) { err(); ret = -EINVAL; goto fail; @@ -291,8 +283,8 @@ size_t max_data_size; break; case NCR_KEY_TYPE_PUBLIC: case NCR_KEY_TYPE_PRIVATE: - size = max_data_size; - + size = ditem->max_data_size; + tmp = kmalloc(size, GFP_KERNEL); if (tmp == NULL) { err(); @@ -301,6 +293,8 @@ size_t max_data_size; } ret = ncr_pk_pack(item, tmp, &size); + ditem->data_size = size; + if (ret < 0) { err(); goto fail; @@ -347,7 +341,6 @@ struct key_item_st* item = NULL; struct data_item_st* ditem = NULL; uint8_t *tmp = NULL; int ret; -size_t data_size; if (unlikely(copy_from_user(&data, arg, sizeof(data)))) { err(); @@ -386,43 +379,36 @@ size_t data_size; if (data.key_id_size > 0) memcpy(item->key_id, data.key_id, data.key_id_size); - ret = ncr_data_item_size(ditem, 0); - if (ret < 0) { - err(); - goto fail; - } - data_size = ret; - switch(item->type) { case NCR_KEY_TYPE_SECRET: - if (data_size > NCR_CIPHER_MAX_KEY_LEN) { + if (ditem->data_size > NCR_CIPHER_MAX_KEY_LEN) { err(); ret = -EINVAL; goto fail; } - ret = ncr_data_item_getd(ditem, item->key.secret.data, data_size, item->flags); + ret = ncr_data_item_getd(ditem, item->key.secret.data, ditem->data_size, item->flags); if (ret < 0) { err(); goto fail; } - item->key.secret.size = data_size; + item->key.secret.size = ditem->data_size; break; case NCR_KEY_TYPE_PRIVATE: case NCR_KEY_TYPE_PUBLIC: - tmp = kmalloc(data_size, GFP_KERNEL); + tmp = kmalloc(ditem->data_size, GFP_KERNEL); if (tmp == NULL) { err(); return -ENOMEM; } - ret = ncr_data_item_getd(ditem, tmp, data_size, item->flags); + ret = ncr_data_item_getd(ditem, tmp, ditem->data_size, item->flags); if (ret < 0) { err(); goto fail; } - ret = ncr_pk_unpack( item, tmp, data_size); + ret = ncr_pk_unpack( item, tmp, ditem->data_size); if (ret < 0) { err(); goto fail; diff --git a/ncr-sessions.c b/ncr-sessions.c index 45cd337..dc03367 100644 --- a/ncr-sessions.c +++ b/ncr-sessions.c @@ -489,7 +489,7 @@ static int _ncr_session_update(struct ncr_lists* lists, struct ncr_session_op_st struct data_item_st* odata = NULL; struct scatterlist *osg; struct scatterlist *isg; - size_t osg_size, isg_size, new_size, max_odata_size, idata_size; + size_t osg_size, isg_size; unsigned int osg_cnt, isg_cnt; sess = ncr_sessions_item_get( &lists->sessions, op->ses); @@ -534,21 +534,7 @@ static int _ncr_session_update(struct ncr_lists* lists, struct ncr_session_op_st isg_size = osg_size; } - ret = ncr_data_item_size(odata, 1); - if (ret < 0) { - err(); - goto fail; - } - max_odata_size = ret; - - ret = ncr_data_item_size(data, 0); - if (ret < 0) { - err(); - goto fail; - } - idata_size = ret; - - if (max_odata_size < idata_size) { + if (odata->max_data_size < data->data_size) { err(); ret = -EINVAL; goto fail; @@ -561,25 +547,21 @@ static int _ncr_session_update(struct ncr_lists* lists, struct ncr_session_op_st err(); goto fail; } - /* FIXME: handle ciphers that do not require that */ - new_size = idata_size; + odata->data_size = data->data_size; } else { /* public key */ - new_size = osg_size; + size_t new_size = osg_size; ret = ncr_pk_cipher_encrypt(&sess->pk, isg, isg_cnt, isg_size, osg, osg_cnt, &new_size); + + odata->data_size = new_size; + if (ret < 0) { err(); goto fail; } } - ret = ncr_data_item_set_size(odata, new_size); - if (ret < 0) { - err(); - goto fail; - } - break; case NCR_OP_DECRYPT: /* obtain data item */ @@ -615,21 +597,7 @@ static int _ncr_session_update(struct ncr_lists* lists, struct ncr_session_op_st isg_size = osg_size; } - ret = ncr_data_item_size(odata, 1); - if (ret < 0) { - err(); - goto fail; - } - max_odata_size = ret; - - ret = ncr_data_item_size(data, 0); - if (ret < 0) { - err(); - goto fail; - } - idata_size = ret; - - if (max_odata_size < idata_size) { + if (odata->max_data_size < data->data_size) { err(); ret = -EINVAL; goto fail; @@ -643,24 +611,20 @@ static int _ncr_session_update(struct ncr_lists* lists, struct ncr_session_op_st goto fail; } /* FIXME: handle ciphers that do not require that */ - new_size = idata_size; + odata->data_size = data->data_size; } else { /* public key */ size_t new_size = osg_size; ret = ncr_pk_cipher_decrypt(&sess->pk, isg, isg_cnt, isg_size, osg, osg_cnt, &new_size); + + odata->data_size = new_size; + if (ret < 0) { err(); goto fail; } } - ret = ncr_data_item_set_size(odata, new_size); - if (ret < 0) { - err(); - goto fail; - } - - break; case NCR_OP_SIGN: @@ -769,7 +733,7 @@ static int _ncr_session_final(struct ncr_lists* lists, struct ncr_session_op_st* int digest_size; uint8_t digest[NCR_HASH_MAX_OUTPUT_SIZE]; struct scatterlist *osg; - size_t osg_size, odata_size, max_odata_size; + size_t osg_size; unsigned int osg_cnt; sess = ncr_sessions_item_get( &lists->sessions, op->ses); @@ -817,13 +781,6 @@ static int _ncr_session_final(struct ncr_lists* lists, struct ncr_session_op_st* goto fail; } - ret = ncr_data_item_size(odata, 0); - if (ret < 0) { - err(); - goto fail; - } - odata_size = ret; - if (algo_is_hmac(sess->algorithm)) { uint8_t vdigest[digest_size]; @@ -832,8 +789,8 @@ static int _ncr_session_final(struct ncr_lists* lists, struct ncr_session_op_st* err(); goto fail; } - - if (digest_size != odata_size || + + if (digest_size != odata->data_size || memcmp(vdigest, digest, digest_size) != 0) { op->err = NCR_VERIFICATION_FAILED; @@ -872,15 +829,8 @@ static int _ncr_session_final(struct ncr_lists* lists, struct ncr_session_op_st* goto fail; } - ret = ncr_data_item_size(odata, 1); - if (ret < 0) { - err(); - goto fail; - } - max_odata_size = ret; - digest_size = sess->hash.digestsize; - if (digest_size == 0 || max_odata_size < digest_size) { + if (digest_size == 0 || odata->max_data_size < digest_size) { err(); ret = -EINVAL; goto fail; @@ -917,12 +867,7 @@ static int _ncr_session_final(struct ncr_lists* lists, struct ncr_session_op_st* err(); goto fail; } - - ret = ncr_data_item_set_size(odata, new_size); - if (ret < 0) { - err(); - goto fail; - } + odata->data_size = new_size; } break; diff --git a/ncr.c b/ncr.c index be0cdc8..5740580 100644 --- a/ncr.c +++ b/ncr.c @@ -126,8 +126,6 @@ ncr_ioctl(struct ncr_lists* lst, struct file *filp, switch (cmd) { case NCRIO_DATA_INIT: return ncr_data_init(&lst->data, arg); - case NCRIO_DATA_INIT_USER: - return ncr_data_init_user(&lst->data, arg); case NCRIO_DATA_GET: return ncr_data_get(&lst->data, arg); case NCRIO_DATA_SET: diff --git a/ncr.h b/ncr.h index 3015889..844cddb 100644 --- a/ncr.h +++ b/ncr.h @@ -63,32 +63,30 @@ typedef enum { typedef int ncr_data_t; #define NCR_DATA_INVALID (ncr_data_t)(0) +typedef enum { + NCR_DATA_KERNEL, + NCR_DATA_USER, +} ncr_data_type_t; + /* When initializing a data_t we can initialize it as a kernel data object * or as an object that points to userspace data. */ struct ncr_data_init_st { ncr_data_t desc; + ncr_data_type_t type; size_t max_object_size; unsigned int flags; void __user *initial_data; /* can be null */ size_t initial_data_size; }; -struct ncr_data_init_user_st { - ncr_data_t desc; - unsigned int flags; - void __user *data; /* can be null */ - size_t __user* data_size_ptr; -}; - struct ncr_data_st { ncr_data_t desc; void __user* data; size_t data_size; /* rw in get */ }; -#define NCRIO_DATA_INIT _IOWR('c', 200, struct ncr_data_init_st) -#define NCRIO_DATA_INIT_USER _IOWR('c', 200, struct ncr_data_init_user_st) +#define NCRIO_DATA_INIT _IOWR('c', 200, struct ncr_data_init_st) #define NCRIO_DATA_GET _IOWR('c', 201, struct ncr_data_st) #define NCRIO_DATA_SET _IOR('c', 202, struct ncr_data_st) #define NCRIO_DATA_DEINIT _IOR('c', 203, ncr_data_t) diff --git a/ncr_int.h b/ncr_int.h index c5be7e5..185b3a3 100644 --- a/ncr_int.h +++ b/ncr_int.h @@ -30,11 +30,6 @@ struct session_item_st { ncr_session_t desc; }; -typedef enum { - NCR_DATA_KERNEL, - NCR_DATA_USER, -} ncr_data_type_t; - #define MAX_DATA_PAGES 64 struct data_item_st { struct list_head list; @@ -43,16 +38,14 @@ struct data_item_st { * not an issue). */ + size_t data_size; + size_t max_data_size; + struct scatterlist _sg[MAX_DATA_PAGES]; /* do not access directly */ union { - struct { - uint8_t* data; - size_t data_size; - size_t max_data_size; - } kernel; + uint8_t* kernel; struct { uint8_t* __user ptr; - size_t* __user size_ptr; struct page *pg[MAX_DATA_PAGES]; size_t pg_cnt; atomic_t pg_used; @@ -127,7 +120,6 @@ int ncr_data_set(struct list_sem_st*, void __user* arg); int ncr_data_get(struct list_sem_st*, void __user* arg); int ncr_data_deinit(struct list_sem_st*, void __user* arg); int ncr_data_init(struct list_sem_st*, void __user* arg); -int ncr_data_init_user(struct list_sem_st*, void __user* arg); void ncr_data_list_deinit(struct list_sem_st*); struct data_item_st* ncr_data_item_get( struct list_sem_st* lst, ncr_data_t desc); void _ncr_data_item_put( struct data_item_st* item); @@ -137,8 +129,7 @@ int ncr_data_item_get_sg( struct data_item_st* item, struct scatterlist** sg, void ncr_data_item_put_sg( struct data_item_st* item); int ncr_data_item_setd( struct data_item_st* item, const void* data, size_t data_size, unsigned int data_flags); int ncr_data_item_getd( struct data_item_st* item, void* data, size_t data_size, unsigned int data_flags); -int ncr_data_item_size( struct data_item_st* item, int max); -int ncr_data_item_set_size( struct data_item_st* item, size_t new_size); + int ncr_key_init(struct list_sem_st*, void __user* arg); int ncr_key_deinit(struct list_sem_st*, void __user* arg); -- cgit