write_unlock(&conn_list_lock);
kvfree(conn->request_buf);
- ksmbd_ida_free(conn->async_ida);
kfree(conn->preauth_info);
kfree(conn);
}
INIT_LIST_HEAD(&conn->async_requests);
spin_lock_init(&conn->request_lock);
spin_lock_init(&conn->credits_lock);
- conn->async_ida = ksmbd_ida_alloc();
+ ida_init(&conn->async_ida);
write_lock(&conn_list_lock);
list_add(&conn->conns_list, &conn_list);
struct sockaddr_storage peer_addr;
/* Identifier for async message */
- struct ksmbd_ida *async_ida;
+ struct ida async_ida;
__le16 cipher_type;
__le16 compress_algorithm;
kfree(work->tr_buf);
kvfree(work->request_buf);
if (work->async_id)
- ksmbd_release_id(work->conn->async_ida, work->async_id);
+ ksmbd_release_id(&work->conn->async_ida, work->async_id);
kmem_cache_free(work_cache, work);
}
#include "ksmbd_ida.h"
-struct ksmbd_ida *ksmbd_ida_alloc(void)
+static inline int __acquire_id(struct ida *ida, int from, int to)
{
- struct ksmbd_ida *ida;
-
- ida = kmalloc(sizeof(struct ksmbd_ida), GFP_KERNEL);
- if (!ida)
- return NULL;
-
- ida_init(&ida->map);
- return ida;
-}
-
-void ksmbd_ida_free(struct ksmbd_ida *ida)
-{
- if (!ida)
- return;
-
- ida_destroy(&ida->map);
- kfree(ida);
-}
-
-static inline int __acquire_id(struct ksmbd_ida *ida, int from, int to)
-{
- return ida_simple_get(&ida->map, from, to, GFP_KERNEL);
+ return ida_simple_get(ida, from, to, GFP_KERNEL);
}
-int ksmbd_acquire_smb2_tid(struct ksmbd_ida *ida)
+int ksmbd_acquire_smb2_tid(struct ida *ida)
{
int id;
- do {
+ id = __acquire_id(ida, 0, 0);
+ if (id == 0xFFFF)
id = __acquire_id(ida, 0, 0);
- } while (id == 0xFFFF);
return id;
}
-int ksmbd_acquire_smb2_uid(struct ksmbd_ida *ida)
+int ksmbd_acquire_smb2_uid(struct ida *ida)
{
int id;
- do {
+ id = __acquire_id(ida, 1, 0);
+ if (id == 0xFFFE)
id = __acquire_id(ida, 1, 0);
- } while (id == 0xFFFE);
return id;
}
-int ksmbd_acquire_async_msg_id(struct ksmbd_ida *ida)
+int ksmbd_acquire_async_msg_id(struct ida *ida)
{
return __acquire_id(ida, 1, 0);
}
-int ksmbd_acquire_id(struct ksmbd_ida *ida)
+int ksmbd_acquire_id(struct ida *ida)
{
return __acquire_id(ida, 0, 0);
}
-void ksmbd_release_id(struct ksmbd_ida *ida, int id)
+void ksmbd_release_id(struct ida *ida, int id)
{
- ida_simple_remove(&ida->map, id);
+ ida_simple_remove(ida, id);
}
#include <linux/slab.h>
#include <linux/idr.h>
-struct ksmbd_ida {
- struct ida map;
-};
-
-struct ksmbd_ida *ksmbd_ida_alloc(void);
-void ksmbd_ida_free(struct ksmbd_ida *ida);
-
/*
* 2.2.1.6.7 TID Generation
* The value 0xFFFF MUST NOT be used as a valid TID. All other
* The value 0xFFFF is used to specify all TIDs or no TID,
* depending upon the context in which it is used.
*/
-int ksmbd_acquire_smb2_tid(struct ksmbd_ida *ida);
+int ksmbd_acquire_smb2_tid(struct ida *ida);
/*
* 2.2.1.6.8 UID Generation
* valid UID.<21> All other possible values for a UID, excluding
* zero (0x0000), are valid.
*/
-int ksmbd_acquire_smb2_uid(struct ksmbd_ida *ida);
-int ksmbd_acquire_async_msg_id(struct ksmbd_ida *ida);
+int ksmbd_acquire_smb2_uid(struct ida *ida);
+int ksmbd_acquire_async_msg_id(struct ida *ida);
-int ksmbd_acquire_id(struct ksmbd_ida *ida);
+int ksmbd_acquire_id(struct ida *ida);
-void ksmbd_release_id(struct ksmbd_ida *ida, int id);
+void ksmbd_release_id(struct ida *ida, int id);
#endif /* __KSMBD_IDA_MANAGEMENT_H__ */
#include "../buffer_pool.h"
#include "../vfs_cache.h"
-static struct ksmbd_ida *session_ida;
+static DEFINE_IDA(session_ida);
#define SESSION_HASH_BITS 3
static DEFINE_HASHTABLE(sessions_table, SESSION_HASH_BITS);
ksmbd_session_rpc_clear_list(sess);
free_channel_list(sess);
kfree(sess->Preauth_HashValue);
- ksmbd_release_id(session_ida, sess->id);
-
- ksmbd_ida_free(sess->tree_conn_ida);
+ ksmbd_release_id(&session_ida, sess->id);
kfree(sess);
}
static int __init_smb2_session(struct ksmbd_session *sess)
{
- int id = ksmbd_acquire_smb2_uid(session_ida);
+ int id = ksmbd_acquire_smb2_uid(&session_ida);
if (id < 0)
return -EINVAL;
if (ret)
goto error;
- sess->tree_conn_ida = ksmbd_ida_alloc();
- if (!sess->tree_conn_ida)
- goto error;
+ ida_init(&sess->tree_conn_ida);
if (protocol == CIFDS_SESSION_FLAG_SMB2) {
down_write(&sessions_table_lock);
int id = -EINVAL;
if (test_session_flag(sess, CIFDS_SESSION_FLAG_SMB2))
- id = ksmbd_acquire_smb2_tid(sess->tree_conn_ida);
+ id = ksmbd_acquire_smb2_tid(&sess->tree_conn_ida);
return id;
}
void ksmbd_release_tree_conn_id(struct ksmbd_session *sess, int id)
{
if (id >= 0)
- ksmbd_release_id(sess->tree_conn_ida, id);
-}
-
-int ksmbd_init_session_table(void)
-{
- session_ida = ksmbd_ida_alloc();
- if (!session_ida)
- return -ENOMEM;
- return 0;
-}
-
-void ksmbd_free_session_table(void)
-{
- ksmbd_ida_free(session_ida);
+ ksmbd_release_id(&sess->tree_conn_ida, id);
}
#define PREAUTH_HASHVALUE_SIZE 64
-struct ksmbd_ida;
struct ksmbd_file_table;
struct channel {
struct hlist_node hlist;
struct list_head ksmbd_chann_list;
struct xarray tree_conns;
- struct ksmbd_ida *tree_conn_ida;
+ struct ida tree_conn_ida;
struct list_head rpc_handle_list;
int ksmbd_session_rpc_method(struct ksmbd_session *sess, int id);
int get_session(struct ksmbd_session *sess);
void put_session(struct ksmbd_session *sess);
-
-int ksmbd_init_session_table(void);
-void ksmbd_free_session_table(void);
-
#endif /* __USER_SESSION_MANAGEMENT_H__ */
ksmbd_workqueue_destroy();
ksmbd_ipc_release();
ksmbd_conn_transport_destroy();
- ksmbd_free_session_table();
ksmbd_crypto_destroy();
ksmbd_free_global_file_table();
destroy_lease_table(NULL);
if (ret)
goto err_unregister;
- ret = ksmbd_init_session_table();
- if (ret)
- goto err_destroy_pools;
-
ret = ksmbd_ipc_init();
if (ret)
goto err_free_session_table;
err_ipc_release:
ksmbd_ipc_release();
err_free_session_table:
- ksmbd_free_session_table();
-err_destroy_pools:
ksmbd_destroy_buffer_pools();
err_unregister:
class_unregister(&ksmbd_control_class);
work->syncronous = true;
if (work->async_id) {
- ksmbd_release_id(conn->async_ida, work->async_id);
+ ksmbd_release_id(&conn->async_ida, work->async_id);
work->async_id = 0;
}
rsp_hdr = work->response_buf;
rsp_hdr->Flags |= SMB2_FLAGS_ASYNC_COMMAND;
- id = ksmbd_acquire_async_msg_id(conn->async_ida);
+ id = ksmbd_acquire_async_msg_id(&conn->async_ida);
if (id < 0) {
ksmbd_err("Failed to alloc async message id\n");
return id;
static DECLARE_RWSEM(ipc_msg_table_lock);
static DEFINE_MUTEX(startup_lock);
-static struct ksmbd_ida *ida;
+static DEFINE_IDA(ipc_ida);
static unsigned int ksmbd_tools_pid;
static void ipc_msg_handle_free(int handle)
{
if (handle >= 0)
- ksmbd_release_id(ida, handle);
+ ksmbd_release_id(&ipc_ida, handle);
}
static int handle_response(int type, void *payload, size_t sz)
msg->type = KSMBD_EVENT_LOGIN_REQUEST;
req = KSMBD_IPC_MSG_PAYLOAD(msg);
- req->handle = ksmbd_acquire_id(ida);
+ req->handle = ksmbd_acquire_id(&ipc_ida);
strscpy(req->account, account, KSMBD_REQ_MAX_ACCOUNT_NAME_SZ);
resp = ipc_msg_send_request(msg, req->handle);
msg->type = KSMBD_EVENT_SPNEGO_AUTHEN_REQUEST;
req = KSMBD_IPC_MSG_PAYLOAD(msg);
- req->handle = ksmbd_acquire_id(ida);
+ req->handle = ksmbd_acquire_id(&ipc_ida);
req->spnego_blob_len = blob_len;
memcpy(req->spnego_blob, spnego_blob, blob_len);
msg->type = KSMBD_EVENT_TREE_CONNECT_REQUEST;
req = KSMBD_IPC_MSG_PAYLOAD(msg);
- req->handle = ksmbd_acquire_id(ida);
+ req->handle = ksmbd_acquire_id(&ipc_ida);
req->account_flags = sess->user->flags;
req->session_id = sess->id;
req->connect_id = tree_conn->id;
msg->type = KSMBD_EVENT_SHARE_CONFIG_REQUEST;
req = KSMBD_IPC_MSG_PAYLOAD(msg);
- req->handle = ksmbd_acquire_id(ida);
+ req->handle = ksmbd_acquire_id(&ipc_ida);
strscpy(req->share_name, name, KSMBD_REQ_MAX_SHARE_NAME);
resp = ipc_msg_send_request(msg, req->handle);
msg->type = KSMBD_EVENT_RPC_REQUEST;
req = KSMBD_IPC_MSG_PAYLOAD(msg);
- req->handle = ksmbd_acquire_id(ida);
+ req->handle = ksmbd_acquire_id(&ipc_ida);
req->flags = rpc_context_flags(sess);
req->flags |= KSMBD_RPC_RAP_METHOD;
req->payload_sz = payload_sz;
int ksmbd_ipc_id_alloc(void)
{
- return ksmbd_acquire_id(ida);
+ return ksmbd_acquire_id(&ipc_ida);
}
void ksmbd_rpc_id_free(int handle)
{
- ksmbd_release_id(ida, handle);
+ ksmbd_release_id(&ipc_ida, handle);
}
void ksmbd_ipc_release(void)
{
cancel_delayed_work_sync(&ipc_timer_work);
- ksmbd_ida_free(ida);
genl_unregister_family(&ksmbd_genl_family);
}
int ksmbd_ipc_init(void)
{
- int ret;
+ int ret = 0;
ksmbd_nl_init_fixup();
INIT_DELAYED_WORK(&ipc_timer_work, ipc_timer_heartbeat);
ret = genl_register_family(&ksmbd_genl_family);
if (ret) {
ksmbd_err("Failed to register KSMBD netlink interface %d\n", ret);
- goto cancel_work;
+ cancel_delayed_work_sync(&ipc_timer_work);
}
- ida = ksmbd_ida_alloc();
- if (!ida) {
- ret = -ENOMEM;
- goto unregister;
- }
- return 0;
-
-unregister:
- genl_unregister_family(&ksmbd_genl_family);
-cancel_work:
- cancel_delayed_work_sync(&ipc_timer_work);
return ret;
}