Lines Matching refs:param
370 static struct mapped_device *dm_hash_rename(struct dm_ioctl *param,
377 unsigned change_uuid = (param->flags & DM_UUID_FLAG) ? 1 : 0;
401 param->name, new);
411 hc = __get_name_cell(param->name);
414 param->name, change_uuid ? "uuid " : "", new);
426 param->name, new, hc->uuid);
446 if (!dm_kobject_uevent(hc->md, KOBJ_CHANGE, param->event_nr))
447 param->flags |= DM_UEVENT_GENERATED_FLAG;
468 typedef int (*ioctl_fn)(struct file *filp, struct dm_ioctl *param, size_t param_size);
470 static int remove_all(struct file *filp, struct dm_ioctl *param, size_t param_size)
472 dm_hash_remove_all(true, !!(param->flags & DM_DEFERRED_REMOVE), false);
473 param->data_size = 0;
494 static void *get_result_buffer(struct dm_ioctl *param, size_t param_size,
497 param->data_start = align_ptr(param + 1) - (void *) param;
499 if (param->data_start < param_size)
500 *len = param_size - param->data_start;
504 return ((void *) param) + param->data_start;
507 static int list_devices(struct file *filp, struct dm_ioctl *param, size_t param_size)
532 nl = orig_nl = get_result_buffer(param, param_size, &len);
534 param->flags |= DM_BUFFER_FULL_FLAG;
537 param->data_size = param->data_start + needed;
580 static void list_version_get_info(struct target_type *tt, void *param)
582 struct vers_iter *info = param;
605 static int __list_versions(struct dm_ioctl *param, size_t param_size, const char *name)
630 vers = get_result_buffer(param, param_size, &len);
632 param->flags |= DM_BUFFER_FULL_FLAG;
635 param->data_size = param->data_start + needed;
650 param->flags |= iter_info.flags;
658 static int list_versions(struct file *filp, struct dm_ioctl *param, size_t param_size)
660 return __list_versions(param, param_size, NULL);
663 static int get_target_version(struct file *filp, struct dm_ioctl *param, size_t param_size)
665 return __list_versions(param, param_size, param->name);
707 struct dm_ioctl *param,
710 return (param->flags & DM_QUERY_INACTIVE_TABLE_FLAG) ?
718 static void __dev_status(struct mapped_device *md, struct dm_ioctl *param)
724 param->flags &= ~(DM_SUSPEND_FLAG | DM_READONLY_FLAG |
728 param->flags |= DM_SUSPEND_FLAG;
731 param->flags |= DM_INTERNAL_SUSPEND_FLAG;
734 param->flags |= DM_DEFERRED_REMOVE;
736 param->dev = huge_encode_dev(disk_devt(disk));
743 param->open_count = dm_open_count(md);
745 param->event_nr = dm_get_event_nr(md);
746 param->target_count = 0;
750 if (!(param->flags & DM_QUERY_INACTIVE_TABLE_FLAG)) {
752 param->flags |= DM_READONLY_FLAG;
753 param->target_count = dm_table_get_num_targets(table);
756 param->flags |= DM_ACTIVE_PRESENT_FLAG;
760 if (param->flags & DM_QUERY_INACTIVE_TABLE_FLAG) {
765 param->flags |= DM_READONLY_FLAG;
766 param->target_count = dm_table_get_num_targets(table);
772 static int dev_create(struct file *filp, struct dm_ioctl *param, size_t param_size)
777 r = check_name(param->name);
781 if (param->flags & DM_PERSISTENT_DEV_FLAG)
782 m = MINOR(huge_decode_dev(param->dev));
788 r = dm_hash_insert(param->name, *param->uuid ? param->uuid : NULL, md);
795 param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
797 __dev_status(md, param);
807 static struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param)
811 if (*param->uuid) {
812 if (*param->name || param->dev)
815 hc = __get_uuid_cell(param->uuid);
818 } else if (*param->name) {
819 if (param->dev)
822 hc = __get_name_cell(param->name);
825 } else if (param->dev) {
826 hc = __get_dev_cell(param->dev);
836 strlcpy(param->name, hc->name, sizeof(param->name));
838 strlcpy(param->uuid, hc->uuid, sizeof(param->uuid));
840 param->uuid[0] = '\0';
843 param->flags |= DM_INACTIVE_PRESENT_FLAG;
845 param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
850 static struct mapped_device *find_device(struct dm_ioctl *param)
856 hc = __find_device_hash_cell(param);
864 static int dev_remove(struct file *filp, struct dm_ioctl *param, size_t param_size)
872 hc = __find_device_hash_cell(param);
885 r = dm_lock_for_deletion(md, !!(param->flags & DM_DEFERRED_REMOVE), false);
887 if (r == -EBUSY && param->flags & DM_DEFERRED_REMOVE) {
906 param->flags &= ~DM_DEFERRED_REMOVE;
908 if (!dm_kobject_uevent(md, KOBJ_REMOVE, param->event_nr))
909 param->flags |= DM_UEVENT_GENERATED_FLAG;
929 static int dev_rename(struct file *filp, struct dm_ioctl *param, size_t param_size)
932 char *new_data = (char *) param + param->data_start;
934 unsigned change_uuid = (param->flags & DM_UUID_FLAG) ? 1 : 0;
936 if (new_data < param->data ||
937 invalid_str(new_data, (void *) param + param_size) || !*new_data ||
949 md = dm_hash_rename(param, new_data);
953 __dev_status(md, param);
959 static int dev_set_geometry(struct file *filp, struct dm_ioctl *param, size_t param_size)
965 char *geostr = (char *) param + param->data_start;
968 md = find_device(param);
972 if (geostr < param->data ||
973 invalid_str(geostr, (void *) param + param_size)) {
999 param->data_size = 0;
1006 static int do_suspend(struct dm_ioctl *param)
1012 md = find_device(param);
1016 if (param->flags & DM_SKIP_LOCKFS_FLAG)
1018 if (param->flags & DM_NOFLUSH_FLAG)
1027 __dev_status(md, param);
1035 static int do_resume(struct dm_ioctl *param)
1045 hc = __find_device_hash_cell(param);
1056 param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
1063 if (param->flags & DM_SKIP_LOCKFS_FLAG)
1065 if (param->flags & DM_NOFLUSH_FLAG)
1086 if (!r && !dm_kobject_uevent(md, KOBJ_CHANGE, param->event_nr))
1087 param->flags |= DM_UEVENT_GENERATED_FLAG;
1098 __dev_status(md, param);
1108 static int dev_suspend(struct file *filp, struct dm_ioctl *param, size_t param_size)
1110 if (param->flags & DM_SUSPEND_FLAG)
1111 return do_suspend(param);
1113 return do_resume(param);
1120 static int dev_status(struct file *filp, struct dm_ioctl *param, size_t param_size)
1124 md = find_device(param);
1128 __dev_status(md, param);
1138 struct dm_ioctl *param, size_t param_size)
1147 outptr = outbuf = get_result_buffer(param, param_size, &len);
1149 if (param->flags & DM_STATUS_TABLE_FLAG)
1162 param->flags |= DM_BUFFER_FULL_FLAG;
1177 param->flags |= DM_BUFFER_FULL_FLAG;
1183 if (param->flags & DM_NOFLUSH_FLAG)
1191 param->flags |= DM_BUFFER_FULL_FLAG;
1196 used = param->data_start + (outptr - outbuf);
1203 param->data_size = used;
1205 param->target_count = num_targets;
1211 static int dev_wait(struct file *filp, struct dm_ioctl *param, size_t param_size)
1218 md = find_device(param);
1225 if (dm_wait_event(md, param->event_nr)) {
1235 __dev_status(md, param);
1237 table = dm_get_live_or_inactive_table(md, param, &srcu_idx);
1239 retrieve_status(table, param, param_size);
1252 static int dev_arm_poll(struct file *filp, struct dm_ioctl *param, size_t param_size)
1261 static inline fmode_t get_mode(struct dm_ioctl *param)
1265 if (param->flags & DM_READONLY_FLAG)
1284 struct dm_ioctl *param, size_t param_size)
1288 struct dm_target_spec *spec = (struct dm_target_spec *) param;
1289 uint32_t next = param->data_start;
1290 void *end = (void *) param + param_size;
1293 if (!param->target_count) {
1298 for (i = 0; i < param->target_count; i++) {
1330 static int table_load(struct file *filp, struct dm_ioctl *param, size_t param_size)
1338 md = find_device(param);
1342 r = dm_table_create(&t, get_mode(param), param->target_count, md);
1348 r = populate_table(t, param, param_size);
1396 param->flags |= DM_INACTIVE_PRESENT_FLAG;
1397 __dev_status(md, param);
1418 static int table_clear(struct file *filp, struct dm_ioctl *param, size_t param_size)
1426 hc = __find_device_hash_cell(param);
1441 param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
1442 __dev_status(md, param);
1457 struct dm_ioctl *param, size_t param_size)
1465 deps = get_result_buffer(param, param_size, &len);
1478 param->flags |= DM_BUFFER_FULL_FLAG;
1490 param->data_size = param->data_start + needed;
1493 static int table_deps(struct file *filp, struct dm_ioctl *param, size_t param_size)
1499 md = find_device(param);
1503 __dev_status(md, param);
1505 table = dm_get_live_or_inactive_table(md, param, &srcu_idx);
1507 retrieve_deps(table, param, param_size);
1519 static int table_status(struct file *filp, struct dm_ioctl *param, size_t param_size)
1525 md = find_device(param);
1529 __dev_status(md, param);
1531 table = dm_get_live_or_inactive_table(md, param, &srcu_idx);
1533 retrieve_status(table, param, param_size);
1574 static int target_message(struct file *filp, struct dm_ioctl *param, size_t param_size)
1581 struct dm_target_msg *tmsg = (void *) param + param->data_start;
1583 char *result = get_result_buffer(param, param_size, &maxlen);
1586 md = find_device(param);
1590 if (tmsg < (struct dm_target_msg *) param->data ||
1591 invalid_str(tmsg->message, (void *) param + param_size)) {
1639 __dev_status(md, param);
1642 param->flags |= DM_DATA_OUT_FLAG;
1644 param->flags |= DM_BUFFER_FULL_FLAG;
1646 param->data_size = param->data_start + strlen(result) + 1;
1743 static void free_params(struct dm_ioctl *param, size_t param_size, int param_flags)
1746 memset(param, 0, param_size);
1749 kvfree(param);
1753 int ioctl_flags, struct dm_ioctl **param, int *param_flags)
1806 *param = dmi;
1815 static int validate_params(uint cmd, struct dm_ioctl *param)
1818 param->flags &= ~DM_BUFFER_FULL_FLAG;
1819 param->flags &= ~DM_UEVENT_GENERATED_FLAG;
1820 param->flags &= ~DM_SECURE_DATA_FLAG;
1821 param->flags &= ~DM_DATA_OUT_FLAG;
1830 if (!*param->name) {
1834 } else if (*param->uuid && *param->name) {
1840 param->name[DM_NAME_LEN - 1] = '\0';
1841 param->uuid[DM_UUID_LEN - 1] = '\0';
1852 struct dm_ioctl *param;
1889 r = copy_params(user, ¶m_kernel, ioctl_flags, ¶m, ¶m_flags);
1894 input_param_size = param->data_size;
1895 r = validate_params(cmd, param);
1899 param->data_size = offsetof(struct dm_ioctl, data);
1900 r = fn(file, param, input_param_size);
1902 if (unlikely(param->flags & DM_BUFFER_FULL_FLAG) &&
1912 if (!r && copy_to_user(user, param, param->data_size))
1916 free_params(param, input_param_size, param_flags);