Do directly call kvmalloc/kvfree().
Signed-off-by: Namjae Jeon <namjae.jeon@samsung.com>
Signed-off-by: Steve French <stfrench@microsoft.com>
*out_len = resp->spnego_blob_len;
retval = 0;
out:
- ksmbd_free(resp);
+ kvfree(resp);
return retval;
}
#else
static LIST_HEAD(wm_lists);
static DEFINE_RWLOCK(wm_lists_lock);
-void *ksmbd_alloc(size_t size)
-{
- return kvmalloc(size, GFP_KERNEL | __GFP_ZERO);
-}
-
-void ksmbd_free(void *ptr)
-{
- kvfree(ptr);
-}
-
static struct wm *wm_alloc(size_t sz, gfp_t flags)
{
struct wm *wm;
wm_list->avail_wm--;
spin_unlock(&wm_list->wm_lock);
- ksmbd_free(wm);
+ kvfree(wm);
}
static void wm_list_free(struct wm_list *l)
}
}
-void ksmbd_free_request(void *addr)
-{
- kvfree(addr);
-}
-
-void *ksmbd_alloc_request(size_t size)
-{
- return kvmalloc(size, GFP_KERNEL);
-}
-
-void ksmbd_free_response(void *buffer)
-{
- kvfree(buffer);
-}
-
-void *ksmbd_alloc_response(size_t size)
-{
- return kvmalloc(size, GFP_KERNEL | __GFP_ZERO);
-}
-
void *ksmbd_find_buffer(size_t size)
{
struct wm *wm;
size_t sz = min(old_sz, new_sz);
void *nptr;
- nptr = ksmbd_alloc_response(new_sz);
+ nptr = kvmalloc(new_sz, GFP_KERNEL | __GFP_ZERO);
if (!nptr)
return ptr;
memcpy(nptr, ptr, sz);
- ksmbd_free_response(ptr);
+ kvfree(ptr);
return nptr;
}
void *ksmbd_find_buffer(size_t size);
void ksmbd_release_buffer(void *buffer);
-void *ksmbd_alloc(size_t size);
-void ksmbd_free(void *ptr);
-
-void ksmbd_free_request(void *addr);
-void *ksmbd_alloc_request(size_t size);
-void ksmbd_free_response(void *buffer);
-void *ksmbd_alloc_response(size_t size);
-
void *ksmbd_realloc_response(void *ptr, size_t old_sz, size_t new_sz);
void ksmbd_free_file_struct(void *filp);
list_del(&conn->conns_list);
write_unlock(&conn_list_lock);
- ksmbd_free_request(conn->request_buf);
+ kvfree(conn->request_buf);
ksmbd_ida_free(conn->async_ida);
kfree(conn->preauth_info);
kfree(conn);
if (try_to_freeze())
continue;
- ksmbd_free_request(conn->request_buf);
+ kvfree(conn->request_buf);
conn->request_buf = NULL;
size = t->ops->read(t, hdr_buf, sizeof(hdr_buf));
/* 4 for rfc1002 length field */
size = pdu_size + 4;
- conn->request_buf = ksmbd_alloc_request(size);
+ conn->request_buf = kvmalloc(size, GFP_KERNEL);
if (!conn->request_buf)
continue;
static struct ksmbd_crypto_ctx *ctx_alloc(void)
{
- return ksmbd_alloc(sizeof(struct ksmbd_crypto_ctx));
+ return kzalloc(sizeof(struct ksmbd_crypto_ctx), GFP_KERNEL);
}
static void ctx_free(struct ksmbd_crypto_ctx *ctx)
free_shash(ctx->desc[i]);
for (i = 0; i < CRYPTO_AEAD_MAX; i++)
free_aead(ctx->ccmaes[i]);
- ksmbd_free(ctx);
+ kfree(ctx);
}
static struct ksmbd_crypto_ctx *ksmbd_find_crypto_ctx(void)
work->set_trans_buf)
ksmbd_release_buffer(work->response_buf);
else
- ksmbd_free_response(work->response_buf);
+ kvfree(work->response_buf);
if (server_conf.flags & KSMBD_GLOBAL_FLAG_CACHE_RBUF &&
work->set_read_buf)
ksmbd_release_buffer(work->aux_payload_buf);
else
- ksmbd_free_response(work->aux_payload_buf);
+ kvfree(work->aux_payload_buf);
- ksmbd_free_response(work->tr_buf);
- ksmbd_free_request(work->request_buf);
+ kfree(work->tr_buf);
+ kvfree(work->request_buf);
if (work->async_id)
ksmbd_release_id(work->conn->async_ida, work->async_id);
kmem_cache_free(work_cache, work);
#include <linux/parser.h>
#include <linux/namei.h>
#include <linux/sched.h>
+#include <linux/mm.h>
#include "share_config.h"
#include "user_config.h"
up_write(&shares_table_lock);
out:
- ksmbd_free(resp);
+ kvfree(resp);
return share;
}
if (!sc)
return status;
- tree_conn = ksmbd_alloc(sizeof(struct ksmbd_tree_connect));
+ tree_conn = kzalloc(sizeof(struct ksmbd_tree_connect), GFP_KERNEL);
if (!tree_conn) {
status.ret = -ENOMEM;
goto out_error;
status.ret = -ENOMEM;
goto out_error;
}
- ksmbd_free(resp);
+ kvfree(resp);
return status;
out_error:
if (tree_conn)
ksmbd_release_tree_conn_id(sess, tree_conn->id);
ksmbd_share_config_put(sc);
- ksmbd_free(tree_conn);
- ksmbd_free(resp);
+ kfree(tree_conn);
+ kvfree(resp);
return status;
}
ksmbd_release_tree_conn_id(sess, tree_conn->id);
xa_erase(&sess->tree_conns, tree_conn->id);
ksmbd_share_config_put(tree_conn->share_conf);
- ksmbd_free(tree_conn);
+ kfree(tree_conn);
return ret;
}
*/
#include <linux/slab.h>
+#include <linux/mm.h>
#include "user_config.h"
#include "../buffer_pool.h"
user = ksmbd_alloc_user(resp);
out:
- ksmbd_free(resp);
+ kvfree(resp);
return user;
}
if (!resp)
pr_err("Unable to close RPC pipe %d\n", entry->id);
- ksmbd_free(resp);
+ kvfree(resp);
ksmbd_rpc_id_free(entry->id);
kfree(entry);
}
if (!resp)
goto error;
- ksmbd_free(resp);
+ kvfree(resp);
return entry->id;
error:
list_del(&entry->list);
work->set_trans_buf)
work->response_buf = ksmbd_find_buffer(sz);
else
- work->response_buf = ksmbd_alloc_response(sz);
+ work->response_buf = kvmalloc(sz, GFP_KERNEL | __GFP_ZERO);
if (!work->response_buf) {
ksmbd_err("Failed to allocate %zu bytes buffer\n", sz);
ksmbd_debug(SMB, "remove xattr failed : %s\n", name);
}
out:
- ksmbd_vfs_xattr_free(xattr_list);
+ kvfree(xattr_list);
return err;
}
buf_free_len -= value_len;
if (buf_free_len < 0) {
- ksmbd_free(buf);
+ kfree(buf);
break;
}
memcpy(ptr, buf, value_len);
- ksmbd_free(buf);
+ kfree(buf);
ptr += value_len;
eainfo->Flags = 0;
rsp->OutputBufferLength = cpu_to_le32(rsp_data_cnt);
inc_rfc1001_len(rsp_org, rsp_data_cnt);
out:
- ksmbd_vfs_xattr_free(xattr_list);
+ kvfree(xattr_list);
return rc;
}
/* last entry offset should be 0 */
file_info->NextEntryOffset = 0;
out:
- ksmbd_vfs_xattr_free(xattr_list);
+ kvfree(xattr_list);
rsp->OutputBufferLength = cpu_to_le32(nbytes);
inc_rfc1001_len(rsp_org, nbytes);
}
work->aux_payload_buf =
- ksmbd_alloc_response(rpc_resp->payload_sz);
+ kvmalloc(rpc_resp->payload_sz, GFP_KERNEL | __GFP_ZERO);
if (!work->aux_payload_buf) {
err = -ENOMEM;
goto out;
nbytes = rpc_resp->payload_sz;
work->resp_hdr_sz = get_rfc1002_len(rsp) + 4;
work->aux_payload_sz = nbytes;
- ksmbd_free(rpc_resp);
+ kvfree(rpc_resp);
}
rsp->StructureSize = cpu_to_le16(17);
out:
rsp->hdr.Status = STATUS_UNEXPECTED_IO_ERROR;
smb2_set_err_rsp(work);
- ksmbd_free(rpc_resp);
+ kvfree(rpc_resp);
return err;
}
ksmbd_find_buffer(conn->vals->max_read_size);
work->set_read_buf = true;
} else {
- work->aux_payload_buf = ksmbd_alloc_response(length);
+ work->aux_payload_buf = kvmalloc(length, GFP_KERNEL | __GFP_ZERO);
}
if (!work->aux_payload_buf) {
err = -ENOMEM;
if (server_conf.flags & KSMBD_GLOBAL_FLAG_CACHE_RBUF)
ksmbd_release_buffer(work->aux_payload_buf);
else
- ksmbd_free_response(work->aux_payload_buf);
+ kvfree(work->aux_payload_buf);
work->aux_payload_buf = NULL;
rsp->hdr.Status = STATUS_END_OF_FILE;
smb2_set_err_rsp(work);
if (server_conf.flags & KSMBD_GLOBAL_FLAG_CACHE_RBUF)
ksmbd_release_buffer(work->aux_payload_buf);
else
- ksmbd_free_response(work->aux_payload_buf);
+ kvfree(work->aux_payload_buf);
work->aux_payload_buf = NULL;
nbytes = 0;
if (rpc_resp) {
if (rpc_resp->flags == KSMBD_RPC_ENOTIMPLEMENTED) {
rsp->hdr.Status = STATUS_NOT_SUPPORTED;
- ksmbd_free(rpc_resp);
+ kvfree(rpc_resp);
smb2_set_err_rsp(work);
return -EOPNOTSUPP;
}
if (rpc_resp->flags != KSMBD_RPC_OK) {
rsp->hdr.Status = STATUS_INVALID_HANDLE;
smb2_set_err_rsp(work);
- ksmbd_free(rpc_resp);
+ kvfree(rpc_resp);
return ret;
}
- ksmbd_free(rpc_resp);
+ kvfree(rpc_resp);
}
rsp->StructureSize = cpu_to_le16(17);
(req->Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE);
work->remote_key = le32_to_cpu(desc->token);
- data_buf = ksmbd_alloc_response(length);
+ data_buf = kvmalloc(length, GFP_KERNEL | __GFP_ZERO);
if (!data_buf)
return -ENOMEM;
le64_to_cpu(desc->offset),
le32_to_cpu(desc->length));
if (ret < 0) {
- ksmbd_free_response(data_buf);
+ kvfree(data_buf);
return ret;
}
ret = ksmbd_vfs_write(work, fp, data_buf, length, &offset, sync, &nbytes);
- ksmbd_free_response(data_buf);
+ kvfree(data_buf);
if (ret < 0)
return ret;
memcpy((char *)rsp->Buffer, rpc_resp->payload, nbytes);
}
out:
- ksmbd_free(rpc_resp);
+ kvfree(rpc_resp);
return nbytes;
}
struct ksmbd_ipc_msg *msg;
size_t msg_sz = sz + sizeof(struct ksmbd_ipc_msg);
- msg = ksmbd_alloc(msg_sz);
+ msg = kvmalloc(msg_sz, GFP_KERNEL | __GFP_ZERO);
if (msg)
msg->sz = sz;
return msg;
static void ipc_msg_free(struct ksmbd_ipc_msg *msg)
{
- ksmbd_free(msg);
+ kvfree(msg);
}
static void ipc_msg_handle_free(int handle)
entry->type + 1, type);
}
- entry->response = ksmbd_alloc(sz);
+ entry->response = kvmalloc(sz, GFP_KERNEL | __GFP_ZERO);
if (!entry->response) {
ret = -ENOMEM;
break;
}
out:
- ksmbd_vfs_xattr_free(xattr_list);
+ kvfree(xattr_list);
return value_len;
}
}
if (v_len < size) {
- wbuf = ksmbd_alloc(size);
+ wbuf = kvmalloc(size, GFP_KERNEL | __GFP_ZERO);
if (!wbuf) {
err = -ENOMEM;
goto out;
fp->filp->f_pos = *pos;
err = 0;
out:
- ksmbd_free(stream_buf);
+ kvfree(stream_buf);
return err;
}
if (size <= 0)
return size;
- vlist = ksmbd_alloc(size);
+ vlist = kvmalloc(size, GFP_KERNEL | __GFP_ZERO);
if (!vlist)
return -ENOMEM;
size = vfs_listxattr(dentry, vlist, size);
if (size < 0) {
ksmbd_debug(VFS, "listxattr failed\n");
- ksmbd_vfs_xattr_free(vlist);
+ kvfree(vlist);
*list = NULL;
}
return vfs_removexattr(&init_user_ns, dentry, attr_name);
}
-void ksmbd_vfs_xattr_free(char *xattr)
-{
- ksmbd_free(xattr);
-}
-
int ksmbd_vfs_unlink(struct dentry *dir, struct dentry *dentry)
{
int err = 0;
}
}
out:
- ksmbd_vfs_xattr_free(xattr_list);
+ kvfree(xattr_list);
return err;
}
}
}
out:
- ksmbd_vfs_xattr_free(xattr_list);
+ kvfree(xattr_list);
return err;
}
n.length = err;
if (ndr_decode_dos_attr(&n, da))
err = -EINVAL;
- ksmbd_free(n.data);
+ kfree(n.data);
} else {
ksmbd_debug(SMB, "failed to load dos attribute in xattr\n");
}
}
out:
- ksmbd_vfs_xattr_free(xattr_list);
+ kvfree(xattr_list);
return value_len;
}
int ksmbd_vfs_xattr_stream_name(char *stream_name, char **xattr_stream_name,
size_t *xattr_stream_name_size, int s_type);
int ksmbd_vfs_remove_xattr(struct dentry *dentry, char *attr_name);
-void ksmbd_vfs_xattr_free(char *xattr);
int ksmbd_vfs_kern_path(char *name, unsigned int flags, struct path *path,
bool caseless);
int ksmbd_vfs_empty_dir(struct ksmbd_file *fp);