Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3a51f7c4 authored by Dmitry Torokhov's avatar Dmitry Torokhov
Browse files

Input: evdev - consolidate compat and regular code 



Compat and normal code mirror each other and are hard to maintain.
When EV_SW was added compat_ioctl case was missed. Here is my attempt
at consolidating the code.

Signed-off-by: default avatarDmitry Torokhov <dtor@mail.ru>
parent e4f5c82a

drivers/input/evdev.c

+213 −280
Original line number Diff line number Diff line
@@ -146,6 +146,7 @@ static int evdev_open(struct inode * inode, struct file * file) 
}



#ifdef CONFIG_COMPAT



struct input_event_compat {

	struct compat_timeval time;

	__u16 type;
@@ -165,22 +166,80 @@ struct input_event_compat { 
#  define COMPAT_TEST test_thread_flag(TIF_32BIT)

#endif



static ssize_t evdev_write_compat(struct file * file, const char __user * buffer, size_t count, loff_t *ppos)

static inline size_t evdev_event_size(void)

{

	struct evdev_list *list = file->private_data;

	struct input_event_compat event;

	int retval = 0;

	return COMPAT_TEST ?

		sizeof(struct input_event_compat) : sizeof(struct input_event);

}



	while (retval < count) {

		if (copy_from_user(&event, buffer + retval, sizeof(struct input_event_compat)))

static int evdev_event_from_user(const char __user *buffer, struct input_event *event)

{

	if (COMPAT_TEST) {

		struct input_event_compat compat_event;



		if (copy_from_user(&compat_event, buffer, sizeof(struct input_event_compat)))

			return -EFAULT;



		event->time.tv_sec = compat_event.time.tv_sec;

		event->time.tv_usec = compat_event.time.tv_usec;

		event->type = compat_event.type;

		event->code = compat_event.code;

		event->value = compat_event.value;



	} else {

		if (copy_from_user(event, buffer, sizeof(struct input_event)))

			return -EFAULT;

		input_event(list->evdev->handle.dev, event.type, event.code, event.value);

		retval += sizeof(struct input_event_compat);

	}



	return retval;

	return 0;

}

#endif



static int evdev_event_to_user(char __user *buffer, const struct input_event *event)

{

	if (COMPAT_TEST) {

		struct input_event_compat compat_event;



		compat_event.time.tv_sec = event->time.tv_sec;

		compat_event.time.tv_usec = event->time.tv_usec;

		compat_event.type = event->type;

		compat_event.code = event->code;

		compat_event.value = event->value;



		if (copy_to_user(buffer, &compat_event, sizeof(struct input_event_compat)))

			return -EFAULT;



	} else {

		if (copy_to_user(buffer, event, sizeof(struct input_event)))

			return -EFAULT;

	}



	return 0;

}



#else



static inline size_t evdev_event_size(void)

{

	return sizeof(struct input_event);

}



static int evdev_event_from_user(const char __user *buffer, struct input_event *event)

{

	if (copy_from_user(event, buffer, sizeof(struct input_event)))

		return -EFAULT;



	return 0;

}



static int evdev_event_to_user(char __user *buffer, const struct input_event *event)

{

	if (copy_to_user(buffer, event, sizeof(struct input_event)))

		return -EFAULT;



	return 0;

}



#endif /* CONFIG_COMPAT */



static ssize_t evdev_write(struct file * file, const char __user * buffer, size_t count, loff_t *ppos)

{
@@ -188,31 +247,26 @@ static ssize_t evdev_write(struct file * file, const char __user * buffer, size_ 
	struct input_event event;

	int retval = 0;



	if (!list->evdev->exist) return -ENODEV;



#ifdef CONFIG_COMPAT

	if (COMPAT_TEST)

		return evdev_write_compat(file, buffer, count, ppos);

#endif

	if (!list->evdev->exist)

		return -ENODEV;



	while (retval < count) {



		if (copy_from_user(&event, buffer + retval, sizeof(struct input_event)))

		if (evdev_event_from_user(buffer + retval, &event))

			return -EFAULT;

		input_event(list->evdev->handle.dev, event.type, event.code, event.value);

		retval += sizeof(struct input_event);

		retval += evdev_event_size();

	}



	return retval;

}



#ifdef CONFIG_COMPAT

static ssize_t evdev_read_compat(struct file * file, char __user * buffer, size_t count, loff_t *ppos)

static ssize_t evdev_read(struct file * file, char __user * buffer, size_t count, loff_t *ppos)

{

	struct evdev_list *list = file->private_data;

	int retval;



	if (count < sizeof(struct input_event_compat))

	if (count < evdev_event_size())

		return -EINVAL;



	if (list->head == list->tail && list->evdev->exist && (file->f_flags & O_NONBLOCK))
@@ -227,80 +281,118 @@ static ssize_t evdev_read_compat(struct file * file, char __user * buffer, size_ 
	if (!list->evdev->exist)

		return -ENODEV;



	while (list->head != list->tail && retval + sizeof(struct input_event_compat) <= count) {

	while (list->head != list->tail && retval + evdev_event_size() <= count) {



		struct input_event *event = (struct input_event *) list->buffer + list->tail;

		struct input_event_compat event_compat;

		event_compat.time.tv_sec = event->time.tv_sec;

		event_compat.time.tv_usec = event->time.tv_usec;

		event_compat.type = event->type;

		event_compat.code = event->code;

		event_compat.value = event->value;



		if (copy_to_user(buffer + retval, &event_compat,

			sizeof(struct input_event_compat))) return -EFAULT;



		if (evdev_event_to_user(buffer + retval, event))

			return -EFAULT;



		list->tail = (list->tail + 1) & (EVDEV_BUFFER_SIZE - 1);

		retval += sizeof(struct input_event_compat);

		retval += evdev_event_size();

	}



	return retval;

}

#endif



static ssize_t evdev_read(struct file * file, char __user * buffer, size_t count, loff_t *ppos)

/* No kernel lock - fine */

static unsigned int evdev_poll(struct file *file, poll_table *wait)

{

	struct evdev_list *list = file->private_data;

	int retval;

	poll_wait(file, &list->evdev->wait, wait);

	return ((list->head == list->tail) ? 0 : (POLLIN | POLLRDNORM)) |

		(list->evdev->exist ? 0 : (POLLHUP | POLLERR));

}



#ifdef CONFIG_COMPAT

	if (COMPAT_TEST)

		return evdev_read_compat(file, buffer, count, ppos);

#endif



	if (count < sizeof(struct input_event))

		return -EINVAL;

#define BITS_PER_LONG_COMPAT (sizeof(compat_long_t) * 8)

#define NBITS_COMPAT(x) ((((x) - 1) / BITS_PER_LONG_COMPAT) + 1)



	if (list->head == list->tail && list->evdev->exist && (file->f_flags & O_NONBLOCK))

		return -EAGAIN;

#ifdef __BIG_ENDIAN

static int bits_to_user(unsigned long *bits, unsigned int maxbit,

			unsigned int maxlen, void __user *p, int compat)

{

	int len, i;



	if (compat) {

		len = NBITS_COMPAT(maxbit) * sizeof(compat_long_t);

		if (len < maxlen)

			len = maxlen;



		for (i = 0; i < len / sizeof(compat_long_t); i++)

			if (copy_to_user((compat_long_t __user *) p + i,

					 (compat_long_t *) bits +

						i + 1 - ((i % 2) << 1),

					 sizeof(compat_long_t)))

				return -EFAULT;

	} else {

		len = NBITS(maxbit) * sizeof(long);

		if (len > maxlen)

			len = maxlen;



	retval = wait_event_interruptible(list->evdev->wait,

		list->head != list->tail || (!list->evdev->exist));

		if (copy_to_user(p, bits, len))

			return -EFAULT;

	}



	if (retval)

		return retval;

	return len;

}

#else

static int bits_to_user(unsigned long *bits, unsigned int maxbit,

			unsigned int maxlen, void __user *p, int compat)

{

	int len = compat ?

			NBITS_COMPAT(maxbit) * sizeof(compat_long_t) :

			NBITS(maxbit) * sizeof(long);



	if (!list->evdev->exist)

		return -ENODEV;

	if (len > maxlen)

		len = maxlen;



	while (list->head != list->tail && retval + sizeof(struct input_event) <= count) {

		if (copy_to_user(buffer + retval, list->buffer + list->tail,

			sizeof(struct input_event))) return -EFAULT;

		list->tail = (list->tail + 1) & (EVDEV_BUFFER_SIZE - 1);

		retval += sizeof(struct input_event);

	return copy_to_user(p, bits, len) ? -EFAULT : len;

}

#endif /* __BIG_ENDIAN */



	return retval;

#else



static int bits_to_user(unsigned long *bits, unsigned int maxbit,

			unsigned int maxlen, void __user *p, int compat)

{

	int len = NBITS(maxbit) * sizeof(long);



	if (len > maxlen)

		len = maxlen;



	return copy_to_user(p, bits, len) ? -EFAULT : len;

}



/* No kernel lock - fine */

static unsigned int evdev_poll(struct file *file, poll_table *wait)

#endif /* CONFIG_COMPAT */



static int str_to_user(const char *str, unsigned int maxlen, void __user *p)

{

	struct evdev_list *list = file->private_data;

	poll_wait(file, &list->evdev->wait, wait);

	return ((list->head == list->tail) ? 0 : (POLLIN | POLLRDNORM)) |

		(list->evdev->exist ? 0 : (POLLHUP | POLLERR));

	int len;



	if (!str)

		return -ENOENT;



	len = strlen(str) + 1;

	if (len > maxlen)

		len = maxlen;



	return copy_to_user(p, str, len) ? -EFAULT : len;

}



static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)

static long evdev_ioctl_handler(struct file *file, unsigned int cmd,

				void __user *p, int compat_mode)

{

	struct evdev_list *list = file->private_data;

	struct evdev *evdev = list->evdev;

	struct input_dev *dev = evdev->handle.dev;

	struct input_absinfo abs;

	void __user *p = (void __user *)arg;

	int __user *ip = (int __user *)arg;

	int __user *ip = (int __user *)p;

	int i, t, u, v;



	if (!evdev->exist) return -ENODEV;

	if (!evdev->exist)

		return -ENODEV;



	switch (cmd) {
@@ -308,26 +400,39 @@ static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 
			return put_user(EV_VERSION, ip);



		case EVIOCGID:

			return copy_to_user(p, &dev->id, sizeof(struct input_id)) ? -EFAULT : 0;

			if (copy_to_user(p, &dev->id, sizeof(struct input_id)))

				return -EFAULT;



			return 0;



		case EVIOCGKEYCODE:

			if (get_user(t, ip)) return -EFAULT;

			if (t < 0 || t >= dev->keycodemax || !dev->keycodesize) return -EINVAL;

			if (put_user(INPUT_KEYCODE(dev, t), ip + 1)) return -EFAULT;

			if (get_user(t, ip))

				return -EFAULT;

			if (t < 0 || t >= dev->keycodemax || !dev->keycodesize)

				return -EINVAL;

			if (put_user(INPUT_KEYCODE(dev, t), ip + 1))

				return -EFAULT;

			return 0;



		case EVIOCSKEYCODE:

			if (get_user(t, ip)) return -EFAULT;

			if (t < 0 || t >= dev->keycodemax || !dev->keycodesize) return -EINVAL;

			if (get_user(v, ip + 1)) return -EFAULT;

			if (v < 0 || v > KEY_MAX) return -EINVAL;

			if (dev->keycodesize < sizeof(v) && (v >> (dev->keycodesize * 8))) return -EINVAL;

			if (get_user(t, ip))

				return -EFAULT;

			if (t < 0 || t >= dev->keycodemax || !dev->keycodesize)

				return -EINVAL;

			if (get_user(v, ip + 1))

				return -EFAULT;

			if (v < 0 || v > KEY_MAX)

				return -EINVAL;

			if (dev->keycodesize < sizeof(v) && (v >> (dev->keycodesize * 8)))

				return -EINVAL;



			u = SET_INPUT_KEYCODE(dev, t, v);

			clear_bit(u, dev->keybit);

			set_bit(v, dev->keybit);

			for (i = 0; i < dev->keycodemax; i++)

				if (INPUT_KEYCODE(dev, i) == u)

					set_bit(u, dev->keybit);



			return 0;



		case EVIOCSFF:
@@ -338,17 +443,17 @@ static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 
				if (copy_from_user(&effect, p, sizeof(effect)))

					return -EFAULT;

				err = dev->upload_effect(dev, &effect);

				if (put_user(effect.id, &(((struct ff_effect __user *)arg)->id)))

				if (put_user(effect.id, &(((struct ff_effect __user *)p)->id)))

					return -EFAULT;

				return err;

			}

			else return -ENOSYS;

			} else

				return -ENOSYS;



		case EVIOCRMFF:

			if (dev->erase_effect) {

				return dev->erase_effect(dev, (int)arg);

			}

			else return -ENOSYS;

			if (!dev->erase_effect)

				return -ENOSYS;



			return dev->erase_effect(dev, (int)(unsigned long) p);



		case EVIOCGEFFECTS:

			if (put_user(dev->ff_effects_max, ip))
@@ -356,7 +461,7 @@ static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 
			return 0;



		case EVIOCGRAB:

			if (arg) {

			if (p) {

				if (evdev->grab)

					return -EBUSY;

				if (input_grab_device(&evdev->handle))
@@ -395,62 +500,33 @@ static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 
						case EV_SW:  bits = dev->swbit;  len = SW_MAX;  break;

						default: return -EINVAL;

					}

					len = NBITS(len) * sizeof(long);

					if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);

					return copy_to_user(p, bits, len) ? -EFAULT : len;

					return bits_to_user(bits, len, _IOC_SIZE(cmd), p, compat_mode);

				}



				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0))) {

					int len;

					len = NBITS(KEY_MAX) * sizeof(long);

					if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);

					return copy_to_user(p, dev->key, len) ? -EFAULT : len;

				}

				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0)))

					return bits_to_user(dev->key, KEY_MAX, _IOC_SIZE(cmd),

							    p, compat_mode);



				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0))) {

					int len;

					len = NBITS(LED_MAX) * sizeof(long);

					if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);

					return copy_to_user(p, dev->led, len) ? -EFAULT : len;

				}

				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0)))

					return bits_to_user(dev->led, LED_MAX, _IOC_SIZE(cmd),

							    p, compat_mode);



				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0))) {

					int len;

					len = NBITS(SND_MAX) * sizeof(long);

					if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);

					return copy_to_user(p, dev->snd, len) ? -EFAULT : len;

				}

				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0)))

					return bits_to_user(dev->snd, SND_MAX, _IOC_SIZE(cmd),

							    p, compat_mode);



				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSW(0))) {

					int len;

					len = NBITS(SW_MAX) * sizeof(long);

					if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);

					return copy_to_user(p, dev->sw, len) ? -EFAULT : len;

				}

				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSW(0)))

					return bits_to_user(dev->sw, SW_MAX, _IOC_SIZE(cmd),

							    p, compat_mode);



				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0))) {

					int len;

					if (!dev->name) return -ENOENT;

					len = strlen(dev->name) + 1;

					if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);

					return copy_to_user(p, dev->name, len) ? -EFAULT : len;

				}

				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0)))

					return str_to_user(dev->name, _IOC_SIZE(cmd), p);



				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0))) {

					int len;

					if (!dev->phys) return -ENOENT;

					len = strlen(dev->phys) + 1;

					if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);

					return copy_to_user(p, dev->phys, len) ? -EFAULT : len;

				}

				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0)))

					return str_to_user(dev->phys, _IOC_SIZE(cmd), p);



				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0))) {

					int len;

					if (!dev->uniq) return -ENOENT;

					len = strlen(dev->uniq) + 1;

					if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);

					return copy_to_user(p, dev->uniq, len) ? -EFAULT : len;

				}

				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0)))

					return str_to_user(dev->uniq, _IOC_SIZE(cmd), p);



				if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
@@ -492,158 +568,15 @@ static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 
	return -EINVAL;

}



#ifdef CONFIG_COMPAT



#define BITS_PER_LONG_COMPAT (sizeof(compat_long_t) * 8)

#define NBITS_COMPAT(x) ((((x)-1)/BITS_PER_LONG_COMPAT)+1)

#define OFF_COMPAT(x)  ((x)%BITS_PER_LONG_COMPAT)

#define BIT_COMPAT(x)  (1UL<<OFF_COMPAT(x))

#define LONG_COMPAT(x) ((x)/BITS_PER_LONG_COMPAT)

#define test_bit_compat(bit, array) ((array[LONG_COMPAT(bit)] >> OFF_COMPAT(bit)) & 1)



#ifdef __BIG_ENDIAN

#define bit_to_user(bit, max) \

do { \

	int i; \

	int len = NBITS_COMPAT((max)) * sizeof(compat_long_t); \

	if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd); \

	for (i = 0; i < len / sizeof(compat_long_t); i++) \

		if (copy_to_user((compat_long_t __user *) p + i, \

				 (compat_long_t*) (bit) + i + 1 - ((i % 2) << 1), \

				 sizeof(compat_long_t))) \

			return -EFAULT; \

	return len; \

} while (0)

#else

#define bit_to_user(bit, max) \

do { \

	int len = NBITS_COMPAT((max)) * sizeof(compat_long_t); \

	if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd); \

	return copy_to_user(p, (bit), len) ? -EFAULT : len; \

} while (0)

#endif



static long evdev_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg)

static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)

{

	struct evdev_list *list = file->private_data;

	struct evdev *evdev = list->evdev;

	struct input_dev *dev = evdev->handle.dev;

	struct input_absinfo abs;

	void __user *p = compat_ptr(arg);



	if (!evdev->exist) return -ENODEV;



	switch (cmd) {



		case EVIOCGVERSION:

		case EVIOCGID:

		case EVIOCGKEYCODE:

		case EVIOCSKEYCODE:

		case EVIOCSFF:

		case EVIOCRMFF:

		case EVIOCGEFFECTS:

		case EVIOCGRAB:

			return evdev_ioctl(file, cmd, (unsigned long) p);



		default:



			if (_IOC_TYPE(cmd) != 'E')

				return -EINVAL;



			if (_IOC_DIR(cmd) == _IOC_READ) {



				if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0,0))) {

					long *bits;

					int max;



					switch (_IOC_NR(cmd) & EV_MAX) {

						case      0: bits = dev->evbit;  max = EV_MAX;  break;

						case EV_KEY: bits = dev->keybit; max = KEY_MAX; break;

						case EV_REL: bits = dev->relbit; max = REL_MAX; break;

						case EV_ABS: bits = dev->absbit; max = ABS_MAX; break;

						case EV_MSC: bits = dev->mscbit; max = MSC_MAX; break;

						case EV_LED: bits = dev->ledbit; max = LED_MAX; break;

						case EV_SND: bits = dev->sndbit; max = SND_MAX; break;

						case EV_FF:  bits = dev->ffbit;  max = FF_MAX;  break;

						case EV_SW:  bits = dev->swbit;  max = SW_MAX;  break;

						default: return -EINVAL;

					}

					bit_to_user(bits, max);

				}



				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0)))

					bit_to_user(dev->key, KEY_MAX);



				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0)))

					bit_to_user(dev->led, LED_MAX);



				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0)))

					bit_to_user(dev->snd, SND_MAX);



				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSW(0)))

					bit_to_user(dev->sw, SW_MAX);



				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0))) {

					int len;

					if (!dev->name) return -ENOENT;

					len = strlen(dev->name) + 1;

					if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);

					return copy_to_user(p, dev->name, len) ? -EFAULT : len;

				}



				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0))) {

					int len;

					if (!dev->phys) return -ENOENT;

					len = strlen(dev->phys) + 1;

					if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);

					return copy_to_user(p, dev->phys, len) ? -EFAULT : len;

				}



				if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0))) {

					int len;

					if (!dev->uniq) return -ENOENT;

					len = strlen(dev->uniq) + 1;

					if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);

					return copy_to_user(p, dev->uniq, len) ? -EFAULT : len;

				}



				if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {



					int t = _IOC_NR(cmd) & ABS_MAX;



					abs.value = dev->abs[t];

					abs.minimum = dev->absmin[t];

					abs.maximum = dev->absmax[t];

					abs.fuzz = dev->absfuzz[t];

					abs.flat = dev->absflat[t];



					if (copy_to_user(p, &abs, sizeof(struct input_absinfo)))

						return -EFAULT;



					return 0;

	return evdev_ioctl_handler(file, cmd, (void __user *)arg, 0);

}

			}



			if (_IOC_DIR(cmd) == _IOC_WRITE) {



				if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {



					int t = _IOC_NR(cmd) & ABS_MAX;



					if (copy_from_user(&abs, p, sizeof(struct input_absinfo)))

						return -EFAULT;



					dev->abs[t] = abs.value;

					dev->absmin[t] = abs.minimum;

					dev->absmax[t] = abs.maximum;

					dev->absfuzz[t] = abs.fuzz;

					dev->absflat[t] = abs.flat;



					return 0;

				}

			}

	}

	return -EINVAL;

#ifdef CONFIG_COMPAT

static long evdev_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg)

{

	return evdev_ioctl_handler(file, cmd, compat_ptr(arg), 1);

}

#endif