diff --git a/home/nipa/nipa_out/843715/ynl/old-code/nfsd-user.c b/home/nipa/nipa_out/843715/ynl/new-code/nfsd-user.c index 9d05eb1cf59d..6f5b2db4e48a 100644 --- a/home/nipa/nipa_out/843715/ynl/old-code/nfsd-user.c +++ b/home/nipa/nipa_out/843715/ynl/new-code/nfsd-user.c @@ -14,6 +14,12 @@ /* Enums */ static const char * const nfsd_op_strmap[] = { [NFSD_CMD_RPC_STATUS_GET] = "rpc-status-get", + [NFSD_CMD_THREADS_SET] = "threads-set", + [NFSD_CMD_THREADS_GET] = "threads-get", + [NFSD_CMD_VERSION_SET] = "version-set", + [NFSD_CMD_VERSION_GET] = "version-get", + [NFSD_CMD_LISTENER_SET] = "listener-set", + [NFSD_CMD_LISTENER_GET] = "listener-get", }; const char *nfsd_op_str(int op) @@ -24,6 +30,27 @@ const char *nfsd_op_str(int op) } /* Policies */ +struct ynl_policy_attr nfsd_version_policy[NFSD_A_VERSION_MAX + 1] = { + [NFSD_A_VERSION_MAJOR] = { .name = "major", .type = YNL_PT_U32, }, + [NFSD_A_VERSION_MINOR] = { .name = "minor", .type = YNL_PT_U32, }, + [NFSD_A_VERSION_ENABLED] = { .name = "enabled", .type = YNL_PT_FLAG, }, +}; + +struct ynl_policy_nest nfsd_version_nest = { + .max_attr = NFSD_A_VERSION_MAX, + .table = nfsd_version_policy, +}; + +struct ynl_policy_attr nfsd_sock_policy[NFSD_A_SOCK_MAX + 1] = { + [NFSD_A_SOCK_ADDR] = { .name = "addr", .type = YNL_PT_BINARY,}, + [NFSD_A_SOCK_TRANSPORT_NAME] = { .name = "transport-name", .type = YNL_PT_NUL_STR, }, +}; + +struct ynl_policy_nest nfsd_sock_nest = { + .max_attr = NFSD_A_SOCK_MAX, + .table = nfsd_sock_policy, +}; + struct ynl_policy_attr nfsd_rpc_status_policy[NFSD_A_RPC_STATUS_MAX + 1] = { [NFSD_A_RPC_STATUS_XID] = { .name = "xid", .type = YNL_PT_U32, }, [NFSD_A_RPC_STATUS_FLAGS] = { .name = "flags", .type = YNL_PT_U32, }, @@ -46,7 +73,139 @@ struct ynl_policy_nest nfsd_rpc_status_nest = { .table = nfsd_rpc_status_policy, }; +struct ynl_policy_attr nfsd_server_worker_policy[NFSD_A_SERVER_WORKER_MAX + 1] = { + [NFSD_A_SERVER_WORKER_THREADS] = { .name = "threads", .type = YNL_PT_U32, }, +}; + +struct ynl_policy_nest nfsd_server_worker_nest = { + .max_attr = NFSD_A_SERVER_WORKER_MAX, + .table = nfsd_server_worker_policy, +}; + +struct ynl_policy_attr nfsd_server_proto_policy[NFSD_A_SERVER_PROTO_MAX + 1] = { + [NFSD_A_SERVER_PROTO_VERSION] = { .name = "version", .type = YNL_PT_NEST, .nest = &nfsd_version_nest, }, +}; + +struct ynl_policy_nest nfsd_server_proto_nest = { + .max_attr = NFSD_A_SERVER_PROTO_MAX, + .table = nfsd_server_proto_policy, +}; + +struct ynl_policy_attr nfsd_server_sock_policy[NFSD_A_SERVER_SOCK_MAX + 1] = { + [NFSD_A_SERVER_SOCK_ADDR] = { .name = "addr", .type = YNL_PT_NEST, .nest = &nfsd_sock_nest, }, +}; + +struct ynl_policy_nest nfsd_server_sock_nest = { + .max_attr = NFSD_A_SERVER_SOCK_MAX, + .table = nfsd_server_sock_policy, +}; + /* Common nested types */ +void nfsd_version_free(struct nfsd_version *obj) +{ +} + +int nfsd_version_put(struct nlmsghdr *nlh, unsigned int attr_type, + struct nfsd_version *obj) +{ + struct nlattr *nest; + + nest = ynl_attr_nest_start(nlh, attr_type); + if (obj->_present.major) + ynl_attr_put_u32(nlh, NFSD_A_VERSION_MAJOR, obj->major); + if (obj->_present.minor) + ynl_attr_put_u32(nlh, NFSD_A_VERSION_MINOR, obj->minor); + if (obj->_present.enabled) + ynl_attr_put(nlh, NFSD_A_VERSION_ENABLED, NULL, 0); + ynl_attr_nest_end(nlh, nest); + + return 0; +} + +int nfsd_version_parse(struct ynl_parse_arg *yarg, const struct nlattr *nested) +{ + struct nfsd_version *dst = yarg->data; + const struct nlattr *attr; + + ynl_attr_for_each_nested(attr, nested) { + unsigned int type = ynl_attr_type(attr); + + if (type == NFSD_A_VERSION_MAJOR) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.major = 1; + dst->major = ynl_attr_get_u32(attr); + } else if (type == NFSD_A_VERSION_MINOR) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.minor = 1; + dst->minor = ynl_attr_get_u32(attr); + } else if (type == NFSD_A_VERSION_ENABLED) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.enabled = 1; + } + } + + return 0; +} + +void nfsd_sock_free(struct nfsd_sock *obj) +{ + free(obj->addr); + free(obj->transport_name); +} + +int nfsd_sock_put(struct nlmsghdr *nlh, unsigned int attr_type, + struct nfsd_sock *obj) +{ + struct nlattr *nest; + + nest = ynl_attr_nest_start(nlh, attr_type); + if (obj->_present.addr_len) + ynl_attr_put(nlh, NFSD_A_SOCK_ADDR, obj->addr, obj->_present.addr_len); + if (obj->_present.transport_name_len) + ynl_attr_put_str(nlh, NFSD_A_SOCK_TRANSPORT_NAME, obj->transport_name); + ynl_attr_nest_end(nlh, nest); + + return 0; +} + +int nfsd_sock_parse(struct ynl_parse_arg *yarg, const struct nlattr *nested) +{ + struct nfsd_sock *dst = yarg->data; + const struct nlattr *attr; + + ynl_attr_for_each_nested(attr, nested) { + unsigned int type = ynl_attr_type(attr); + + if (type == NFSD_A_SOCK_ADDR) { + unsigned int len; + + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + + len = ynl_attr_data_len(attr); + dst->_present.addr_len = len; + dst->addr = malloc(len); + memcpy(dst->addr, ynl_attr_data(attr), len); + } else if (type == NFSD_A_SOCK_TRANSPORT_NAME) { + unsigned int len; + + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + + len = strnlen(ynl_attr_get_str(attr), ynl_attr_data_len(attr)); + dst->_present.transport_name_len = len; + dst->transport_name = malloc(len + 1); + memcpy(dst->transport_name, ynl_attr_get_str(attr), len); + dst->transport_name[len] = 0; + } + } + + return 0; +} + /* ============== NFSD_CMD_RPC_STATUS_GET ============== */ /* NFSD_CMD_RPC_STATUS_GET - dump */ int nfsd_rpc_status_get_rsp_dump_parse(const struct nlmsghdr *nlh, @@ -198,6 +357,310 @@ nfsd_rpc_status_get_dump(struct ynl_sock *ys) return NULL; } +/* ============== NFSD_CMD_THREADS_SET ============== */ +/* NFSD_CMD_THREADS_SET - do */ +void nfsd_threads_set_req_free(struct nfsd_threads_set_req *req) +{ + free(req); +} + +int nfsd_threads_set(struct ynl_sock *ys, struct nfsd_threads_set_req *req) +{ + struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; + struct nlmsghdr *nlh; + int err; + + nlh = ynl_gemsg_start_req(ys, ys->family_id, NFSD_CMD_THREADS_SET, 1); + ys->req_policy = &nfsd_server_worker_nest; + + if (req->_present.threads) + ynl_attr_put_u32(nlh, NFSD_A_SERVER_WORKER_THREADS, req->threads); + + err = ynl_exec(ys, nlh, &yrs); + if (err < 0) + return -1; + + return 0; +} + +/* ============== NFSD_CMD_THREADS_GET ============== */ +/* NFSD_CMD_THREADS_GET - do */ +void nfsd_threads_get_rsp_free(struct nfsd_threads_get_rsp *rsp) +{ + free(rsp); +} + +int nfsd_threads_get_rsp_parse(const struct nlmsghdr *nlh, + struct ynl_parse_arg *yarg) +{ + struct nfsd_threads_get_rsp *dst; + const struct nlattr *attr; + + dst = yarg->data; + + ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { + unsigned int type = ynl_attr_type(attr); + + if (type == NFSD_A_SERVER_WORKER_THREADS) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.threads = 1; + dst->threads = ynl_attr_get_u32(attr); + } + } + + return YNL_PARSE_CB_OK; +} + +struct nfsd_threads_get_rsp *nfsd_threads_get(struct ynl_sock *ys) +{ + struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; + struct nfsd_threads_get_rsp *rsp; + struct nlmsghdr *nlh; + int err; + + nlh = ynl_gemsg_start_req(ys, ys->family_id, NFSD_CMD_THREADS_GET, 1); + ys->req_policy = &nfsd_server_worker_nest; + yrs.yarg.rsp_policy = &nfsd_server_worker_nest; + + rsp = calloc(1, sizeof(*rsp)); + yrs.yarg.data = rsp; + yrs.cb = nfsd_threads_get_rsp_parse; + yrs.rsp_cmd = NFSD_CMD_THREADS_GET; + + err = ynl_exec(ys, nlh, &yrs); + if (err < 0) + goto err_free; + + return rsp; + +err_free: + nfsd_threads_get_rsp_free(rsp); + return NULL; +} + +/* ============== NFSD_CMD_VERSION_SET ============== */ +/* NFSD_CMD_VERSION_SET - do */ +void nfsd_version_set_req_free(struct nfsd_version_set_req *req) +{ + unsigned int i; + + for (i = 0; i < req->n_version; i++) + nfsd_version_free(&req->version[i]); + free(req->version); + free(req); +} + +int nfsd_version_set(struct ynl_sock *ys, struct nfsd_version_set_req *req) +{ + struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; + struct nlmsghdr *nlh; + int err; + + nlh = ynl_gemsg_start_req(ys, ys->family_id, NFSD_CMD_VERSION_SET, 1); + ys->req_policy = &nfsd_server_proto_nest; + + for (unsigned int i = 0; i < req->n_version; i++) + nfsd_version_put(nlh, NFSD_A_SERVER_PROTO_VERSION, &req->version[i]); + + err = ynl_exec(ys, nlh, &yrs); + if (err < 0) + return -1; + + return 0; +} + +/* ============== NFSD_CMD_VERSION_GET ============== */ +/* NFSD_CMD_VERSION_GET - do */ +void nfsd_version_get_rsp_free(struct nfsd_version_get_rsp *rsp) +{ + unsigned int i; + + for (i = 0; i < rsp->n_version; i++) + nfsd_version_free(&rsp->version[i]); + free(rsp->version); + free(rsp); +} + +int nfsd_version_get_rsp_parse(const struct nlmsghdr *nlh, + struct ynl_parse_arg *yarg) +{ + struct nfsd_version_get_rsp *dst; + unsigned int n_version = 0; + const struct nlattr *attr; + struct ynl_parse_arg parg; + int i; + + dst = yarg->data; + parg.ys = yarg->ys; + + if (dst->version) + return ynl_error_parse(yarg, "attribute already present (server-proto.version)"); + + ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { + unsigned int type = ynl_attr_type(attr); + + if (type == NFSD_A_SERVER_PROTO_VERSION) { + n_version++; + } + } + + if (n_version) { + dst->version = calloc(n_version, sizeof(*dst->version)); + dst->n_version = n_version; + i = 0; + parg.rsp_policy = &nfsd_version_nest; + ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { + if (ynl_attr_type(attr) == NFSD_A_SERVER_PROTO_VERSION) { + parg.data = &dst->version[i]; + if (nfsd_version_parse(&parg, attr)) + return YNL_PARSE_CB_ERROR; + i++; + } + } + } + + return YNL_PARSE_CB_OK; +} + +struct nfsd_version_get_rsp *nfsd_version_get(struct ynl_sock *ys) +{ + struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; + struct nfsd_version_get_rsp *rsp; + struct nlmsghdr *nlh; + int err; + + nlh = ynl_gemsg_start_req(ys, ys->family_id, NFSD_CMD_VERSION_GET, 1); + ys->req_policy = &nfsd_server_proto_nest; + yrs.yarg.rsp_policy = &nfsd_server_proto_nest; + + rsp = calloc(1, sizeof(*rsp)); + yrs.yarg.data = rsp; + yrs.cb = nfsd_version_get_rsp_parse; + yrs.rsp_cmd = NFSD_CMD_VERSION_GET; + + err = ynl_exec(ys, nlh, &yrs); + if (err < 0) + goto err_free; + + return rsp; + +err_free: + nfsd_version_get_rsp_free(rsp); + return NULL; +} + +/* ============== NFSD_CMD_LISTENER_SET ============== */ +/* NFSD_CMD_LISTENER_SET - do */ +void nfsd_listener_set_req_free(struct nfsd_listener_set_req *req) +{ + unsigned int i; + + for (i = 0; i < req->n_addr; i++) + nfsd_sock_free(&req->addr[i]); + free(req->addr); + free(req); +} + +int nfsd_listener_set(struct ynl_sock *ys, struct nfsd_listener_set_req *req) +{ + struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; + struct nlmsghdr *nlh; + int err; + + nlh = ynl_gemsg_start_req(ys, ys->family_id, NFSD_CMD_LISTENER_SET, 1); + ys->req_policy = &nfsd_server_sock_nest; + + for (unsigned int i = 0; i < req->n_addr; i++) + nfsd_sock_put(nlh, NFSD_A_SERVER_SOCK_ADDR, &req->addr[i]); + + err = ynl_exec(ys, nlh, &yrs); + if (err < 0) + return -1; + + return 0; +} + +/* ============== NFSD_CMD_LISTENER_GET ============== */ +/* NFSD_CMD_LISTENER_GET - do */ +void nfsd_listener_get_rsp_free(struct nfsd_listener_get_rsp *rsp) +{ + unsigned int i; + + for (i = 0; i < rsp->n_addr; i++) + nfsd_sock_free(&rsp->addr[i]); + free(rsp->addr); + free(rsp); +} + +int nfsd_listener_get_rsp_parse(const struct nlmsghdr *nlh, + struct ynl_parse_arg *yarg) +{ + struct nfsd_listener_get_rsp *dst; + const struct nlattr *attr; + struct ynl_parse_arg parg; + unsigned int n_addr = 0; + int i; + + dst = yarg->data; + parg.ys = yarg->ys; + + if (dst->addr) + return ynl_error_parse(yarg, "attribute already present (server-sock.addr)"); + + ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { + unsigned int type = ynl_attr_type(attr); + + if (type == NFSD_A_SERVER_SOCK_ADDR) { + n_addr++; + } + } + + if (n_addr) { + dst->addr = calloc(n_addr, sizeof(*dst->addr)); + dst->n_addr = n_addr; + i = 0; + parg.rsp_policy = &nfsd_sock_nest; + ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { + if (ynl_attr_type(attr) == NFSD_A_SERVER_SOCK_ADDR) { + parg.data = &dst->addr[i]; + if (nfsd_sock_parse(&parg, attr)) + return YNL_PARSE_CB_ERROR; + i++; + } + } + } + + return YNL_PARSE_CB_OK; +} + +struct nfsd_listener_get_rsp *nfsd_listener_get(struct ynl_sock *ys) +{ + struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; + struct nfsd_listener_get_rsp *rsp; + struct nlmsghdr *nlh; + int err; + + nlh = ynl_gemsg_start_req(ys, ys->family_id, NFSD_CMD_LISTENER_GET, 1); + ys->req_policy = &nfsd_server_sock_nest; + yrs.yarg.rsp_policy = &nfsd_server_sock_nest; + + rsp = calloc(1, sizeof(*rsp)); + yrs.yarg.data = rsp; + yrs.cb = nfsd_listener_get_rsp_parse; + yrs.rsp_cmd = NFSD_CMD_LISTENER_GET; + + err = ynl_exec(ys, nlh, &yrs); + if (err < 0) + goto err_free; + + return rsp; + +err_free: + nfsd_listener_get_rsp_free(rsp); + return NULL; +} + const struct ynl_family ynl_nfsd_family = { .name = "nfsd", .hdr_len = sizeof(struct genlmsghdr), diff --git a/home/nipa/nipa_out/843715/ynl/old-code/nfsd-user.h b/home/nipa/nipa_out/843715/ynl/new-code/nfsd-user.h index 989c6e209ced..0695b5a6e1e5 100644 --- a/home/nipa/nipa_out/843715/ynl/old-code/nfsd-user.h +++ b/home/nipa/nipa_out/843715/ynl/new-code/nfsd-user.h @@ -19,6 +19,27 @@ extern const struct ynl_family ynl_nfsd_family; const char *nfsd_op_str(int op); /* Common nested types */ +struct nfsd_version { + struct { + __u32 major:1; + __u32 minor:1; + __u32 enabled:1; + } _present; + + __u32 major; + __u32 minor; +}; + +struct nfsd_sock { + struct { + __u32 addr_len; + __u32 transport_name_len; + } _present; + + void *addr; + char *transport_name; +}; + /* ============== NFSD_CMD_RPC_STATUS_GET ============== */ /* NFSD_CMD_RPC_STATUS_GET - dump */ struct nfsd_rpc_status_get_rsp_dump { @@ -64,4 +85,136 @@ nfsd_rpc_status_get_rsp_list_free(struct nfsd_rpc_status_get_rsp_list *rsp); struct nfsd_rpc_status_get_rsp_list * nfsd_rpc_status_get_dump(struct ynl_sock *ys); +/* ============== NFSD_CMD_THREADS_SET ============== */ +/* NFSD_CMD_THREADS_SET - do */ +struct nfsd_threads_set_req { + struct { + __u32 threads:1; + } _present; + + __u32 threads; +}; + +static inline struct nfsd_threads_set_req *nfsd_threads_set_req_alloc(void) +{ + return calloc(1, sizeof(struct nfsd_threads_set_req)); +} +void nfsd_threads_set_req_free(struct nfsd_threads_set_req *req); + +static inline void +nfsd_threads_set_req_set_threads(struct nfsd_threads_set_req *req, + __u32 threads) +{ + req->_present.threads = 1; + req->threads = threads; +} + +/* + * set the number of running threads + */ +int nfsd_threads_set(struct ynl_sock *ys, struct nfsd_threads_set_req *req); + +/* ============== NFSD_CMD_THREADS_GET ============== */ +/* NFSD_CMD_THREADS_GET - do */ + +struct nfsd_threads_get_rsp { + struct { + __u32 threads:1; + } _present; + + __u32 threads; +}; + +void nfsd_threads_get_rsp_free(struct nfsd_threads_get_rsp *rsp); + +/* + * get the number of running threads + */ +struct nfsd_threads_get_rsp *nfsd_threads_get(struct ynl_sock *ys); + +/* ============== NFSD_CMD_VERSION_SET ============== */ +/* NFSD_CMD_VERSION_SET - do */ +struct nfsd_version_set_req { + unsigned int n_version; + struct nfsd_version *version; +}; + +static inline struct nfsd_version_set_req *nfsd_version_set_req_alloc(void) +{ + return calloc(1, sizeof(struct nfsd_version_set_req)); +} +void nfsd_version_set_req_free(struct nfsd_version_set_req *req); + +static inline void +__nfsd_version_set_req_set_version(struct nfsd_version_set_req *req, + struct nfsd_version *version, + unsigned int n_version) +{ + free(req->version); + req->version = version; + req->n_version = n_version; +} + +/* + * set nfs enabled versions + */ +int nfsd_version_set(struct ynl_sock *ys, struct nfsd_version_set_req *req); + +/* ============== NFSD_CMD_VERSION_GET ============== */ +/* NFSD_CMD_VERSION_GET - do */ + +struct nfsd_version_get_rsp { + unsigned int n_version; + struct nfsd_version *version; +}; + +void nfsd_version_get_rsp_free(struct nfsd_version_get_rsp *rsp); + +/* + * get nfs enabled versions + */ +struct nfsd_version_get_rsp *nfsd_version_get(struct ynl_sock *ys); + +/* ============== NFSD_CMD_LISTENER_SET ============== */ +/* NFSD_CMD_LISTENER_SET - do */ +struct nfsd_listener_set_req { + unsigned int n_addr; + struct nfsd_sock *addr; +}; + +static inline struct nfsd_listener_set_req *nfsd_listener_set_req_alloc(void) +{ + return calloc(1, sizeof(struct nfsd_listener_set_req)); +} +void nfsd_listener_set_req_free(struct nfsd_listener_set_req *req); + +static inline void +__nfsd_listener_set_req_set_addr(struct nfsd_listener_set_req *req, + struct nfsd_sock *addr, unsigned int n_addr) +{ + free(req->addr); + req->addr = addr; + req->n_addr = n_addr; +} + +/* + * set nfs running sockets + */ +int nfsd_listener_set(struct ynl_sock *ys, struct nfsd_listener_set_req *req); + +/* ============== NFSD_CMD_LISTENER_GET ============== */ +/* NFSD_CMD_LISTENER_GET - do */ + +struct nfsd_listener_get_rsp { + unsigned int n_addr; + struct nfsd_sock *addr; +}; + +void nfsd_listener_get_rsp_free(struct nfsd_listener_get_rsp *rsp); + +/* + * get nfs running listeners + */ +struct nfsd_listener_get_rsp *nfsd_listener_get(struct ynl_sock *ys); + #endif /* _LINUX_NFSD_GEN_H */