Lines Matching refs:param
426 static struct mapped_device *dm_hash_rename(struct dm_ioctl *param,
433 unsigned int change_uuid = (param->flags & DM_UUID_FLAG) ? 1 : 0;
456 param->name, new);
466 hc = __get_name_cell(param->name);
469 param->name, change_uuid ? "uuid " : "", new);
481 param->name, new, hc->uuid);
501 if (!dm_kobject_uevent(hc->md, KOBJ_CHANGE, param->event_nr, false))
502 param->flags |= DM_UEVENT_GENERATED_FLAG;
528 typedef int (*ioctl_fn)(struct file *filp, struct dm_ioctl *param, size_t param_size);
530 static int remove_all(struct file *filp, struct dm_ioctl *param, size_t param_size)
532 dm_hash_remove_all(true, !!(param->flags & DM_DEFERRED_REMOVE), false);
533 param->data_size = 0;
554 static void *get_result_buffer(struct dm_ioctl *param, size_t param_size,
557 param->data_start = align_ptr(param + 1) - (void *) param;
559 if (param->data_start < param_size)
560 *len = param_size - param->data_start;
564 return ((void *) param) + param->data_start;
591 static int list_devices(struct file *filp, struct dm_ioctl *param, size_t param_size)
608 if (!filter_device(hc, param->name, param->uuid))
612 if (param->flags & DM_UUID_FLAG && hc->uuid)
619 nl = orig_nl = get_result_buffer(param, param_size, &len);
621 param->flags |= DM_BUFFER_FULL_FLAG;
624 param->data_size = param->data_start + needed;
635 if (!filter_device(hc, param->name, param->uuid))
650 if (param->flags & DM_UUID_FLAG) {
681 static void list_version_get_info(struct target_type *tt, void *param)
683 struct vers_iter *info = param;
704 static int __list_versions(struct dm_ioctl *param, size_t param_size, const char *name)
729 vers = get_result_buffer(param, param_size, &len);
731 param->flags |= DM_BUFFER_FULL_FLAG;
734 param->data_size = param->data_start + needed;
749 param->flags |= iter_info.flags;
757 static int list_versions(struct file *filp, struct dm_ioctl *param, size_t param_size)
759 return __list_versions(param, param_size, NULL);
762 static int get_target_version(struct file *filp, struct dm_ioctl *param, size_t param_size)
764 return __list_versions(param, param_size, param->name);
813 struct dm_ioctl *param,
816 return (param->flags & DM_QUERY_INACTIVE_TABLE_FLAG) ?
824 static void __dev_status(struct mapped_device *md, struct dm_ioctl *param)
830 param->flags &= ~(DM_SUSPEND_FLAG | DM_READONLY_FLAG |
834 param->flags |= DM_SUSPEND_FLAG;
837 param->flags |= DM_INTERNAL_SUSPEND_FLAG;
840 param->flags |= DM_DEFERRED_REMOVE;
842 param->dev = huge_encode_dev(disk_devt(disk));
849 param->open_count = dm_open_count(md);
851 param->event_nr = dm_get_event_nr(md);
852 param->target_count = 0;
856 if (!(param->flags & DM_QUERY_INACTIVE_TABLE_FLAG)) {
858 param->flags |= DM_READONLY_FLAG;
859 param->target_count = table->num_targets;
862 param->flags |= DM_ACTIVE_PRESENT_FLAG;
866 if (param->flags & DM_QUERY_INACTIVE_TABLE_FLAG) {
872 param->flags |= DM_READONLY_FLAG;
873 param->target_count = table->num_targets;
879 static int dev_create(struct file *filp, struct dm_ioctl *param, size_t param_size)
884 r = check_name(param->name);
888 if (param->flags & DM_PERSISTENT_DEV_FLAG)
889 m = MINOR(huge_decode_dev(param->dev));
895 r = dm_hash_insert(param->name, *param->uuid ? param->uuid : NULL, md);
902 param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
904 __dev_status(md, param);
914 static struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param)
918 if (*param->uuid) {
919 if (*param->name || param->dev) {
921 param->uuid, param->name, (unsigned long long)param->dev);
925 hc = __get_uuid_cell(param->uuid);
928 } else if (*param->name) {
929 if (param->dev) {
931 param->name, (unsigned long long)param->dev);
935 hc = __get_name_cell(param->name);
938 } else if (param->dev) {
939 hc = __get_dev_cell(param->dev);
949 strscpy(param->name, hc->name, sizeof(param->name));
951 strscpy(param->uuid, hc->uuid, sizeof(param->uuid));
953 param->uuid[0] = '\0';
956 param->flags |= DM_INACTIVE_PRESENT_FLAG;
958 param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
963 static struct mapped_device *find_device(struct dm_ioctl *param)
969 hc = __find_device_hash_cell(param);
977 static int dev_remove(struct file *filp, struct dm_ioctl *param, size_t param_size)
985 hc = __find_device_hash_cell(param);
998 r = dm_lock_for_deletion(md, !!(param->flags & DM_DEFERRED_REMOVE), false);
1000 if (r == -EBUSY && param->flags & DM_DEFERRED_REMOVE) {
1019 param->flags &= ~DM_DEFERRED_REMOVE;
1023 if (!dm_kobject_uevent(md, KOBJ_REMOVE, param->event_nr, false))
1024 param->flags |= DM_UEVENT_GENERATED_FLAG;
1044 static int dev_rename(struct file *filp, struct dm_ioctl *param, size_t param_size)
1047 char *new_data = (char *) param + param->data_start;
1049 unsigned int change_uuid = (param->flags & DM_UUID_FLAG) ? 1 : 0;
1051 if (new_data < param->data ||
1052 invalid_str(new_data, (void *) param + param_size) || !*new_data ||
1064 md = dm_hash_rename(param, new_data);
1068 __dev_status(md, param);
1074 static int dev_set_geometry(struct file *filp, struct dm_ioctl *param, size_t param_size)
1080 char *geostr = (char *) param + param->data_start;
1083 md = find_device(param);
1087 if (geostr < param->data ||
1088 invalid_str(geostr, (void *) param + param_size)) {
1113 param->data_size = 0;
1120 static int do_suspend(struct dm_ioctl *param)
1126 md = find_device(param);
1130 if (param->flags & DM_SKIP_LOCKFS_FLAG)
1132 if (param->flags & DM_NOFLUSH_FLAG)
1141 __dev_status(md, param);
1149 static int do_resume(struct dm_ioctl *param)
1160 hc = __find_device_hash_cell(param);
1171 param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
1180 if (param->flags & DM_SKIP_LOCKFS_FLAG)
1182 if (param->flags & DM_NOFLUSH_FLAG)
1210 if (!dm_kobject_uevent(md, KOBJ_CHANGE, param->event_nr, need_resize_uevent))
1211 param->flags |= DM_UEVENT_GENERATED_FLAG;
1223 __dev_status(md, param);
1233 static int dev_suspend(struct file *filp, struct dm_ioctl *param, size_t param_size)
1235 if (param->flags & DM_SUSPEND_FLAG)
1236 return do_suspend(param);
1238 return do_resume(param);
1245 static int dev_status(struct file *filp, struct dm_ioctl *param, size_t param_size)
1249 md = find_device(param);
1253 __dev_status(md, param);
1263 struct dm_ioctl *param, size_t param_size)
1272 outptr = outbuf = get_result_buffer(param, param_size, &len);
1274 if (param->flags & DM_STATUS_TABLE_FLAG)
1276 else if (param->flags & DM_IMA_MEASUREMENT_FLAG)
1289 param->flags |= DM_BUFFER_FULL_FLAG;
1304 param->flags |= DM_BUFFER_FULL_FLAG;
1310 if (param->flags & DM_NOFLUSH_FLAG)
1318 param->flags |= DM_BUFFER_FULL_FLAG;
1323 used = param->data_start + (outptr - outbuf);
1330 param->data_size = used;
1332 param->target_count = num_targets;
1338 static int dev_wait(struct file *filp, struct dm_ioctl *param, size_t param_size)
1345 md = find_device(param);
1352 if (dm_wait_event(md, param->event_nr)) {
1362 __dev_status(md, param);
1364 table = dm_get_live_or_inactive_table(md, param, &srcu_idx);
1366 retrieve_status(table, param, param_size);
1379 static int dev_arm_poll(struct file *filp, struct dm_ioctl *param, size_t param_size)
1388 static inline blk_mode_t get_mode(struct dm_ioctl *param)
1392 if (param->flags & DM_READONLY_FLAG)
1433 struct dm_ioctl *param, size_t param_size)
1437 struct dm_target_spec *spec = (struct dm_target_spec *) param;
1438 uint32_t next = param->data_start;
1439 const char *const end = (const char *) param + param_size;
1443 if (!param->target_count) {
1448 for (i = 0; i < param->target_count; i++) {
1496 static int table_load(struct file *filp, struct dm_ioctl *param, size_t param_size)
1504 md = find_device(param);
1508 r = dm_table_create(&t, get_mode(param), param->target_count, md);
1514 r = populate_table(t, param, param_size);
1561 param->flags |= DM_INACTIVE_PRESENT_FLAG;
1562 __dev_status(md, param);
1583 static int table_clear(struct file *filp, struct dm_ioctl *param, size_t param_size)
1592 hc = __find_device_hash_cell(param);
1608 param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
1609 __dev_status(md, param);
1625 struct dm_ioctl *param, size_t param_size)
1635 deps = get_result_buffer(param, param_size, &len);
1648 param->flags |= DM_BUFFER_FULL_FLAG;
1660 param->data_size = param->data_start + needed;
1666 static int table_deps(struct file *filp, struct dm_ioctl *param, size_t param_size)
1672 md = find_device(param);
1676 __dev_status(md, param);
1678 table = dm_get_live_or_inactive_table(md, param, &srcu_idx);
1680 retrieve_deps(table, param, param_size);
1692 static int table_status(struct file *filp, struct dm_ioctl *param, size_t param_size)
1698 md = find_device(param);
1702 __dev_status(md, param);
1704 table = dm_get_live_or_inactive_table(md, param, &srcu_idx);
1706 retrieve_status(table, param, param_size);
1747 static int target_message(struct file *filp, struct dm_ioctl *param, size_t param_size)
1754 struct dm_target_msg *tmsg = (void *) param + param->data_start;
1756 char *result = get_result_buffer(param, param_size, &maxlen);
1759 md = find_device(param);
1763 if (tmsg < (struct dm_target_msg *) param->data ||
1764 invalid_str(tmsg->message, (void *) param + param_size)) {
1812 __dev_status(md, param);
1815 param->flags |= DM_DATA_OUT_FLAG;
1817 param->flags |= DM_BUFFER_FULL_FLAG;
1819 param->data_size = param->data_start + strlen(result) + 1;
1922 static void free_params(struct dm_ioctl *param, size_t param_size, int param_flags)
1925 memset(param, 0, param_size);
1928 kvfree(param);
1932 int ioctl_flags, struct dm_ioctl **param, int *param_flags)
1988 *param = dmi;
1997 static int validate_params(uint cmd, struct dm_ioctl *param)
2000 param->flags &= ~DM_BUFFER_FULL_FLAG;
2001 param->flags &= ~DM_UEVENT_GENERATED_FLAG;
2002 param->flags &= ~DM_SECURE_DATA_FLAG;
2003 param->flags &= ~DM_DATA_OUT_FLAG;
2012 if (!*param->name) {
2016 } else if (*param->uuid && *param->name) {
2022 param->name[DM_NAME_LEN - 1] = '\0';
2023 param->uuid[DM_UUID_LEN - 1] = '\0';
2034 struct dm_ioctl *param;
2071 r = copy_params(user, ¶m_kernel, ioctl_flags, ¶m, ¶m_flags);
2076 input_param_size = param->data_size;
2077 r = validate_params(cmd, param);
2081 param->data_size = offsetof(struct dm_ioctl, data);
2082 r = fn(file, param, input_param_size);
2084 if (unlikely(param->flags & DM_BUFFER_FULL_FLAG) &&
2094 if (!r && copy_to_user(user, param, param->data_size))
2098 free_params(param, input_param_size, param_flags);