static int crypt_decode_key(u8 *key, char *hex, unsigned int size)
 {
        char buffer[3];
-       char *endp;
        unsigned int i;
 
        buffer[2] = '\0';
                buffer[0] = *hex++;
                buffer[1] = *hex++;
 
-               key[i] = (u8)simple_strtoul(buffer, &endp, 16);
-
-               if (endp != &buffer[2])
+               if (kstrtou8(buffer, 16, &key[i]))
                        return -EINVAL;
        }
 
 
 static int set_chunk_size(struct dm_exception_store *store,
                          const char *chunk_size_arg, char **error)
 {
-       unsigned long chunk_size_ulong;
-       char *value;
+       unsigned chunk_size;
 
-       chunk_size_ulong = simple_strtoul(chunk_size_arg, &value, 10);
-       if (*chunk_size_arg == '\0' || *value != '\0' ||
-           chunk_size_ulong > UINT_MAX) {
+       if (kstrtouint(chunk_size_arg, 10, &chunk_size)) {
                *error = "Invalid chunk size";
                return -EINVAL;
        }
 
-       if (!chunk_size_ulong) {
+       if (!chunk_size) {
                store->chunk_size = store->chunk_mask = store->chunk_shift = 0;
                return 0;
        }
 
-       return dm_exception_store_set_chunk_size(store,
-                                                (unsigned) chunk_size_ulong,
-                                                error);
+       return dm_exception_store_set_chunk_size(store, chunk_size, error);
 }
 
 int dm_exception_store_set_chunk_size(struct dm_exception_store *store,
 
        sector_t width;
        uint32_t stripes;
        uint32_t chunk_size;
-       char *end;
        int r;
        unsigned int i;
 
                return -EINVAL;
        }
 
-       stripes = simple_strtoul(argv[0], &end, 10);
-       if (!stripes || *end) {
+       if (kstrtouint(argv[0], 10, &stripes) || !stripes) {
                ti->error = "Invalid stripe count";
                return -EINVAL;
        }
 
-       chunk_size = simple_strtoul(argv[1], &end, 10);
-       if (*end) {
+       if (kstrtouint(argv[1], 10, &chunk_size)) {
                ti->error = "Invalid chunk_size";
                return -EINVAL;
        }