tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

ALSA: Convert strlcpy to strscpy when return value is unused

strlcpy is deprecated. see: Documentation/process/deprecated.rst

Change the calls that do not use the strlcpy return value to the
preferred strscpy.

Done with cocci script:

@@
expression e1, e2, e3;
@@

- strlcpy(
+ strscpy(
e1, e2, e3);

This cocci script leaves the instances where the return value is
used unchanged.

After this patch, sound/ has 3 uses of strlcpy() that need to be
manually inspected for conversion and changed one day.

$ git grep -w strlcpy sound/
sound/usb/card.c: len = strlcpy(card->longname, s, sizeof(card->longname));
sound/usb/mixer.c: return strlcpy(buf, p->name, buflen);
sound/usb/mixer.c: return strlcpy(buf, p->names[index], buflen);

Miscellenea:

o Remove trailing whitespace in conversion of sound/core/hwdep.c

Link: https://lore.kernel.org/lkml/CAHk-=wgfRnXz0W3D37d01q3JFkr_i_uTL=V6A6G1oUZcprmknw@mail.gmail.com/

Signed-off-by: Joe Perches <joe@perches.com>
Acked-by: Mark Brown <broonie@kernel.org>
Link: https://lore.kernel.org/r/22b393d1790bb268769d0bab7bacf0866dcb0c14.camel@perches.com
Signed-off-by: Takashi Iwai <tiwai@suse.de>

authored by

Joe Perches and committed by
Takashi Iwai 75b1a8f9 6dcb8bf9

+134 -134
+1 -1
sound/aoa/codecs/onyx.c
··· 1013 1013 goto fail; 1014 1014 } 1015 1015 1016 - strlcpy(onyx->codec.name, "onyx", MAX_CODEC_NAME_LEN); 1016 + strscpy(onyx->codec.name, "onyx", MAX_CODEC_NAME_LEN); 1017 1017 onyx->codec.owner = THIS_MODULE; 1018 1018 onyx->codec.init = onyx_init_codec; 1019 1019 onyx->codec.exit = onyx_exit_codec;
+1 -1
sound/aoa/codecs/tas.c
··· 894 894 /* seems that half is a saner default */ 895 895 tas->drc_range = TAS3004_DRC_MAX / 2; 896 896 897 - strlcpy(tas->codec.name, "tas", MAX_CODEC_NAME_LEN); 897 + strscpy(tas->codec.name, "tas", MAX_CODEC_NAME_LEN); 898 898 tas->codec.owner = THIS_MODULE; 899 899 tas->codec.init = tas_init_codec; 900 900 tas->codec.exit = tas_exit_codec;
+1 -1
sound/aoa/codecs/toonie.c
··· 126 126 if (!toonie) 127 127 return -ENOMEM; 128 128 129 - strlcpy(toonie->codec.name, "toonie", sizeof(toonie->codec.name)); 129 + strscpy(toonie->codec.name, "toonie", sizeof(toonie->codec.name)); 130 130 toonie->codec.owner = THIS_MODULE; 131 131 toonie->codec.init = toonie_init_codec; 132 132 toonie->codec.exit = toonie_exit_codec;
+4 -4
sound/aoa/core/alsa.c
··· 28 28 return err; 29 29 aoa_card = alsa_card->private_data; 30 30 aoa_card->alsa_card = alsa_card; 31 - strlcpy(alsa_card->driver, "AppleOnbdAudio", sizeof(alsa_card->driver)); 32 - strlcpy(alsa_card->shortname, name, sizeof(alsa_card->shortname)); 33 - strlcpy(alsa_card->longname, name, sizeof(alsa_card->longname)); 34 - strlcpy(alsa_card->mixername, name, sizeof(alsa_card->mixername)); 31 + strscpy(alsa_card->driver, "AppleOnbdAudio", sizeof(alsa_card->driver)); 32 + strscpy(alsa_card->shortname, name, sizeof(alsa_card->shortname)); 33 + strscpy(alsa_card->longname, name, sizeof(alsa_card->longname)); 34 + strscpy(alsa_card->mixername, name, sizeof(alsa_card->mixername)); 35 35 err = snd_card_register(aoa_card->alsa_card); 36 36 if (err < 0) { 37 37 printk(KERN_ERR "snd-aoa: couldn't register alsa card\n");
+3 -3
sound/aoa/fabrics/layout.c
··· 948 948 ldev->gpio.methods->set_lineout(codec->gpio, 1); 949 949 ctl = snd_ctl_new1(&lineout_ctl, codec->gpio); 950 950 if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE) 951 - strlcpy(ctl->id.name, 951 + strscpy(ctl->id.name, 952 952 "Headphone Switch", sizeof(ctl->id.name)); 953 953 ldev->lineout_ctrl = ctl; 954 954 aoa_snd_ctl_add(ctl); ··· 962 962 ctl = snd_ctl_new1(&lineout_detect_choice, 963 963 ldev); 964 964 if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE) 965 - strlcpy(ctl->id.name, 965 + strscpy(ctl->id.name, 966 966 "Headphone Detect Autoswitch", 967 967 sizeof(ctl->id.name)); 968 968 aoa_snd_ctl_add(ctl); 969 969 ctl = snd_ctl_new1(&lineout_detected, 970 970 ldev); 971 971 if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE) 972 - strlcpy(ctl->id.name, 972 + strscpy(ctl->id.name, 973 973 "Headphone Detected", 974 974 sizeof(ctl->id.name)); 975 975 ldev->lineout_detected_ctrl = ctl;
+1 -1
sound/aoa/soundbus/sysfs.c
··· 13 13 int length; 14 14 15 15 if (*sdev->modalias) { 16 - strlcpy(buf, sdev->modalias, sizeof(sdev->modalias) + 1); 16 + strscpy(buf, sdev->modalias, sizeof(sdev->modalias) + 1); 17 17 strcat(buf, "\n"); 18 18 length = strlen(buf); 19 19 } else {
+3 -3
sound/arm/aaci.c
··· 890 890 891 891 card->private_free = aaci_free_card; 892 892 893 - strlcpy(card->driver, DRIVER_NAME, sizeof(card->driver)); 894 - strlcpy(card->shortname, "ARM AC'97 Interface", sizeof(card->shortname)); 893 + strscpy(card->driver, DRIVER_NAME, sizeof(card->driver)); 894 + strscpy(card->shortname, "ARM AC'97 Interface", sizeof(card->shortname)); 895 895 snprintf(card->longname, sizeof(card->longname), 896 896 "%s PL%03x rev%u at 0x%08llx, irq %d", 897 897 card->shortname, amba_part(dev), amba_rev(dev), ··· 921 921 pcm->private_data = aaci; 922 922 pcm->info_flags = 0; 923 923 924 - strlcpy(pcm->name, DRIVER_NAME, sizeof(pcm->name)); 924 + strscpy(pcm->name, DRIVER_NAME, sizeof(pcm->name)); 925 925 926 926 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &aaci_playback_ops); 927 927 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &aaci_capture_ops);
+1 -1
sound/arm/pxa2xx-ac97.c
··· 235 235 if (ret < 0) 236 236 goto err; 237 237 238 - strlcpy(card->driver, dev->dev.driver->name, sizeof(card->driver)); 238 + strscpy(card->driver, dev->dev.driver->name, sizeof(card->driver)); 239 239 240 240 ret = pxa2xx_ac97_pcm_new(card); 241 241 if (ret)
+1 -1
sound/core/compress_offload.c
··· 1132 1132 1133 1133 static inline void snd_compress_set_id(struct snd_compr *compr, const char *id) 1134 1134 { 1135 - strlcpy(compr->id, id, sizeof(compr->id)); 1135 + strscpy(compr->id, id, sizeof(compr->id)); 1136 1136 } 1137 1137 #else 1138 1138 static inline int snd_compress_proc_init(struct snd_compr *compr)
+8 -8
sound/core/control.c
··· 261 261 kctl->id.device = ncontrol->device; 262 262 kctl->id.subdevice = ncontrol->subdevice; 263 263 if (ncontrol->name) { 264 - strlcpy(kctl->id.name, ncontrol->name, sizeof(kctl->id.name)); 264 + strscpy(kctl->id.name, ncontrol->name, sizeof(kctl->id.name)); 265 265 if (strcmp(ncontrol->name, kctl->id.name) != 0) 266 266 pr_warn("ALSA: Control name '%s' truncated to '%s'\n", 267 267 ncontrol->name, kctl->id.name); ··· 701 701 return -ENOMEM; 702 702 down_read(&snd_ioctl_rwsem); 703 703 info->card = card->number; 704 - strlcpy(info->id, card->id, sizeof(info->id)); 705 - strlcpy(info->driver, card->driver, sizeof(info->driver)); 706 - strlcpy(info->name, card->shortname, sizeof(info->name)); 707 - strlcpy(info->longname, card->longname, sizeof(info->longname)); 708 - strlcpy(info->mixername, card->mixername, sizeof(info->mixername)); 709 - strlcpy(info->components, card->components, sizeof(info->components)); 704 + strscpy(info->id, card->id, sizeof(info->id)); 705 + strscpy(info->driver, card->driver, sizeof(info->driver)); 706 + strscpy(info->name, card->shortname, sizeof(info->name)); 707 + strscpy(info->longname, card->longname, sizeof(info->longname)); 708 + strscpy(info->mixername, card->mixername, sizeof(info->mixername)); 709 + strscpy(info->components, card->components, sizeof(info->components)); 710 710 up_read(&snd_ioctl_rwsem); 711 711 if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info))) { 712 712 kfree(info); ··· 2137 2137 WARN(strlen(names[info->value.enumerated.item]) >= sizeof(info->value.enumerated.name), 2138 2138 "ALSA: too long item name '%s'\n", 2139 2139 names[info->value.enumerated.item]); 2140 - strlcpy(info->value.enumerated.name, 2140 + strscpy(info->value.enumerated.name, 2141 2141 names[info->value.enumerated.item], 2142 2142 sizeof(info->value.enumerated.name)); 2143 2143 return 0;
+1 -1
sound/core/ctljack.c
··· 35 35 36 36 sid.index = 0; 37 37 sid.iface = SNDRV_CTL_ELEM_IFACE_CARD; 38 - strlcpy(sid.name, name, sizeof(sid.name)); 38 + strscpy(sid.name, name, sizeof(sid.name)); 39 39 40 40 while (snd_ctl_find_id(card, &sid)) { 41 41 sid.index++;
+3 -3
sound/core/hwdep.c
··· 177 177 178 178 memset(&info, 0, sizeof(info)); 179 179 info.card = hw->card->number; 180 - strlcpy(info.id, hw->id, sizeof(info.id)); 181 - strlcpy(info.name, hw->name, sizeof(info.name)); 180 + strscpy(info.id, hw->id, sizeof(info.id)); 181 + strscpy(info.name, hw->name, sizeof(info.name)); 182 182 info.iface = hw->iface; 183 183 if (copy_to_user(_info, &info, sizeof(info))) 184 184 return -EFAULT; ··· 379 379 hwdep->card = card; 380 380 hwdep->device = device; 381 381 if (id) 382 - strlcpy(hwdep->id, id, sizeof(hwdep->id)); 382 + strscpy(hwdep->id, id, sizeof(hwdep->id)); 383 383 384 384 snd_device_initialize(&hwdep->dev, card); 385 385 hwdep->dev.release = release_hwdep_device;
+2 -2
sound/core/init.c
··· 174 174 if (extra_size > 0) 175 175 card->private_data = (char *)card + sizeof(struct snd_card); 176 176 if (xid) 177 - strlcpy(card->id, xid, sizeof(card->id)); 177 + strscpy(card->id, xid, sizeof(card->id)); 178 178 err = 0; 179 179 mutex_lock(&snd_card_mutex); 180 180 if (idx < 0) /* first check the matching module-name slot */ ··· 623 623 /* last resort... */ 624 624 dev_err(card->dev, "unable to set card id (%s)\n", id); 625 625 if (card->proc_root->name) 626 - strlcpy(card->id, card->proc_root->name, sizeof(card->id)); 626 + strscpy(card->id, card->proc_root->name, sizeof(card->id)); 627 627 } 628 628 629 629 /**
+6 -6
sound/core/oss/mixer_oss.c
··· 87 87 struct mixer_info info; 88 88 89 89 memset(&info, 0, sizeof(info)); 90 - strlcpy(info.id, mixer && mixer->id[0] ? mixer->id : card->driver, sizeof(info.id)); 91 - strlcpy(info.name, mixer && mixer->name[0] ? mixer->name : card->mixername, sizeof(info.name)); 90 + strscpy(info.id, mixer && mixer->id[0] ? mixer->id : card->driver, sizeof(info.id)); 91 + strscpy(info.name, mixer && mixer->name[0] ? mixer->name : card->mixername, sizeof(info.name)); 92 92 info.modify_counter = card->mixer_oss_change_count; 93 93 if (copy_to_user(_info, &info, sizeof(info))) 94 94 return -EFAULT; ··· 103 103 _old_mixer_info info; 104 104 105 105 memset(&info, 0, sizeof(info)); 106 - strlcpy(info.id, mixer && mixer->id[0] ? mixer->id : card->driver, sizeof(info.id)); 107 - strlcpy(info.name, mixer && mixer->name[0] ? mixer->name : card->mixername, sizeof(info.name)); 106 + strscpy(info.id, mixer && mixer->id[0] ? mixer->id : card->driver, sizeof(info.id)); 107 + strscpy(info.name, mixer && mixer->name[0] ? mixer->name : card->mixername, sizeof(info.name)); 108 108 if (copy_to_user(_info, &info, sizeof(info))) 109 109 return -EFAULT; 110 110 return 0; ··· 499 499 500 500 memset(&id, 0, sizeof(id)); 501 501 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 502 - strlcpy(id.name, name, sizeof(id.name)); 502 + strscpy(id.name, name, sizeof(id.name)); 503 503 id.index = index; 504 504 return snd_ctl_find_id(card, &id); 505 505 } ··· 1355 1355 mixer->oss_dev_alloc = 1; 1356 1356 mixer->card = card; 1357 1357 if (*card->mixername) 1358 - strlcpy(mixer->name, card->mixername, sizeof(mixer->name)); 1358 + strscpy(mixer->name, card->mixername, sizeof(mixer->name)); 1359 1359 else 1360 1360 snprintf(mixer->name, sizeof(mixer->name), 1361 1361 "mixer%i", card->number);
+1 -1
sound/core/pcm.c
··· 729 729 init_waitqueue_head(&pcm->open_wait); 730 730 INIT_LIST_HEAD(&pcm->list); 731 731 if (id) 732 - strlcpy(pcm->id, id, sizeof(pcm->id)); 732 + strscpy(pcm->id, id, sizeof(pcm->id)); 733 733 734 734 err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK, 735 735 playback_count);
+3 -3
sound/core/pcm_native.c
··· 209 209 info->device = pcm->device; 210 210 info->stream = substream->stream; 211 211 info->subdevice = substream->number; 212 - strlcpy(info->id, pcm->id, sizeof(info->id)); 213 - strlcpy(info->name, pcm->name, sizeof(info->name)); 212 + strscpy(info->id, pcm->id, sizeof(info->id)); 213 + strscpy(info->name, pcm->name, sizeof(info->name)); 214 214 info->dev_class = pcm->dev_class; 215 215 info->dev_subclass = pcm->dev_subclass; 216 216 info->subdevices_count = pstr->substream_count; 217 217 info->subdevices_avail = pstr->substream_count - pstr->substream_opened; 218 - strlcpy(info->subname, substream->name, sizeof(info->subname)); 218 + strscpy(info->subname, substream->name, sizeof(info->subname)); 219 219 220 220 return 0; 221 221 }
+1 -1
sound/core/rawmidi.c
··· 1686 1686 INIT_LIST_HEAD(&rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams); 1687 1687 1688 1688 if (id != NULL) 1689 - strlcpy(rmidi->id, id, sizeof(rmidi->id)); 1689 + strscpy(rmidi->id, id, sizeof(rmidi->id)); 1690 1690 1691 1691 snd_device_initialize(&rmidi->dev, card); 1692 1692 rmidi->dev.release = release_rawmidi_device;
+2 -2
sound/core/seq/oss/seq_oss_midi.c
··· 173 173 snd_use_lock_init(&mdev->use_lock); 174 174 175 175 /* copy and truncate the name of synth device */ 176 - strlcpy(mdev->name, pinfo->name, sizeof(mdev->name)); 176 + strscpy(mdev->name, pinfo->name, sizeof(mdev->name)); 177 177 178 178 /* create MIDI coder */ 179 179 if (snd_midi_event_new(MAX_MIDI_EVENT_BUF, &mdev->coder) < 0) { ··· 647 647 inf->device = dev; 648 648 inf->dev_type = 0; /* FIXME: ?? */ 649 649 inf->capabilities = 0; /* FIXME: ?? */ 650 - strlcpy(inf->name, mdev->name, sizeof(inf->name)); 650 + strscpy(inf->name, mdev->name, sizeof(inf->name)); 651 651 snd_use_lock_free(&mdev->use_lock); 652 652 return 0; 653 653 }
+3 -3
sound/core/seq/oss/seq_oss_synth.c
··· 107 107 snd_use_lock_init(&rec->use_lock); 108 108 109 109 /* copy and truncate the name of synth device */ 110 - strlcpy(rec->name, dev->name, sizeof(rec->name)); 110 + strscpy(rec->name, dev->name, sizeof(rec->name)); 111 111 112 112 /* registration */ 113 113 spin_lock_irqsave(&register_lock, flags); ··· 616 616 inf->synth_subtype = 0; 617 617 inf->nr_voices = 16; 618 618 inf->device = dev; 619 - strlcpy(inf->name, minf.name, sizeof(inf->name)); 619 + strscpy(inf->name, minf.name, sizeof(inf->name)); 620 620 } else { 621 621 if ((rec = get_synthdev(dp, dev)) == NULL) 622 622 return -ENXIO; ··· 624 624 inf->synth_subtype = rec->synth_subtype; 625 625 inf->nr_voices = rec->nr_voices; 626 626 inf->device = dev; 627 - strlcpy(inf->name, rec->name, sizeof(inf->name)); 627 + strscpy(inf->name, rec->name, sizeof(inf->name)); 628 628 snd_use_lock_free(&rec->use_lock); 629 629 } 630 630 return 0;
+1 -1
sound/core/seq/seq_clientmgr.c
··· 1584 1584 info->queue = q->queue; 1585 1585 info->owner = q->owner; 1586 1586 info->locked = q->locked; 1587 - strlcpy(info->name, q->name, sizeof(info->name)); 1587 + strscpy(info->name, q->name, sizeof(info->name)); 1588 1588 queuefree(q); 1589 1589 1590 1590 return 0;
+3 -3
sound/core/seq/seq_ports.c
··· 327 327 328 328 /* set port name */ 329 329 if (info->name[0]) 330 - strlcpy(port->name, info->name, sizeof(port->name)); 330 + strscpy(port->name, info->name, sizeof(port->name)); 331 331 332 332 /* set capabilities */ 333 333 port->capability = info->capability; ··· 356 356 return -EINVAL; 357 357 358 358 /* get port name */ 359 - strlcpy(info->name, port->name, sizeof(info->name)); 359 + strscpy(info->name, port->name, sizeof(info->name)); 360 360 361 361 /* get capabilities */ 362 362 info->capability = port->capability; ··· 654 654 /* Set up the port */ 655 655 memset(&portinfo, 0, sizeof(portinfo)); 656 656 portinfo.addr.client = client; 657 - strlcpy(portinfo.name, portname ? portname : "Unnamed port", 657 + strscpy(portinfo.name, portname ? portname : "Unnamed port", 658 658 sizeof(portinfo.name)); 659 659 660 660 portinfo.capability = cap;
+5 -5
sound/core/timer.c
··· 959 959 timer->tmr_device = tid->device; 960 960 timer->tmr_subdevice = tid->subdevice; 961 961 if (id) 962 - strlcpy(timer->id, id, sizeof(timer->id)); 962 + strscpy(timer->id, id, sizeof(timer->id)); 963 963 timer->sticks = 1; 964 964 INIT_LIST_HEAD(&timer->device_list); 965 965 INIT_LIST_HEAD(&timer->open_list_head); ··· 1659 1659 ginfo->card = t->card ? t->card->number : -1; 1660 1660 if (t->hw.flags & SNDRV_TIMER_HW_SLAVE) 1661 1661 ginfo->flags |= SNDRV_TIMER_FLG_SLAVE; 1662 - strlcpy(ginfo->id, t->id, sizeof(ginfo->id)); 1663 - strlcpy(ginfo->name, t->name, sizeof(ginfo->name)); 1662 + strscpy(ginfo->id, t->id, sizeof(ginfo->id)); 1663 + strscpy(ginfo->name, t->name, sizeof(ginfo->name)); 1664 1664 ginfo->resolution = t->hw.resolution; 1665 1665 if (t->hw.resolution_min > 0) { 1666 1666 ginfo->resolution_min = t->hw.resolution_min; ··· 1814 1814 info->card = t->card ? t->card->number : -1; 1815 1815 if (t->hw.flags & SNDRV_TIMER_HW_SLAVE) 1816 1816 info->flags |= SNDRV_TIMER_FLG_SLAVE; 1817 - strlcpy(info->id, t->id, sizeof(info->id)); 1818 - strlcpy(info->name, t->name, sizeof(info->name)); 1817 + strscpy(info->id, t->id, sizeof(info->id)); 1818 + strscpy(info->name, t->name, sizeof(info->name)); 1819 1819 info->resolution = t->hw.resolution; 1820 1820 if (copy_to_user(_info, info, sizeof(*_info))) 1821 1821 err = -EFAULT;
+2 -2
sound/core/timer_compat.c
··· 61 61 info.card = t->card ? t->card->number : -1; 62 62 if (t->hw.flags & SNDRV_TIMER_HW_SLAVE) 63 63 info.flags |= SNDRV_TIMER_FLG_SLAVE; 64 - strlcpy(info.id, t->id, sizeof(info.id)); 65 - strlcpy(info.name, t->name, sizeof(info.name)); 64 + strscpy(info.id, t->id, sizeof(info.id)); 65 + strscpy(info.name, t->name, sizeof(info.name)); 66 66 info.resolution = t->hw.resolution; 67 67 if (copy_to_user(_info, &info, sizeof(*_info))) 68 68 return -EFAULT;
+1 -1
sound/drivers/opl3/opl3_oss.c
··· 97 97 return; 98 98 99 99 opl3->oss_seq_dev = dev; 100 - strlcpy(dev->name, name, sizeof(dev->name)); 100 + strscpy(dev->name, name, sizeof(dev->name)); 101 101 arg = SNDRV_SEQ_DEVICE_ARGPTR(dev); 102 102 arg->type = SYNTH_TYPE_FM; 103 103 if (opl3->hardware < OPL3_HW_OPL3) {
+1 -1
sound/drivers/opl3/opl3_synth.c
··· 290 290 } 291 291 292 292 if (name) 293 - strlcpy(patch->name, name, sizeof(patch->name)); 293 + strscpy(patch->name, name, sizeof(patch->name)); 294 294 295 295 return 0; 296 296 }
+1 -1
sound/firewire/bebob/bebob_hwdep.c
··· 80 80 info.card = dev->card->index; 81 81 *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]); 82 82 *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]); 83 - strlcpy(info.device_name, dev_name(&dev->device), 83 + strscpy(info.device_name, dev_name(&dev->device), 84 84 sizeof(info.device_name)); 85 85 86 86 if (copy_to_user(arg, &info, sizeof(info)))
+1 -1
sound/firewire/dice/dice-hwdep.c
··· 79 79 info.card = dev->card->index; 80 80 *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]); 81 81 *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]); 82 - strlcpy(info.device_name, dev_name(&dev->device), 82 + strscpy(info.device_name, dev_name(&dev->device), 83 83 sizeof(info.device_name)); 84 84 85 85 if (copy_to_user(arg, &info, sizeof(info)))
+1 -1
sound/firewire/digi00x/digi00x-hwdep.c
··· 87 87 info.card = dev->card->index; 88 88 *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]); 89 89 *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]); 90 - strlcpy(info.device_name, dev_name(&dev->device), 90 + strscpy(info.device_name, dev_name(&dev->device), 91 91 sizeof(info.device_name)); 92 92 93 93 if (copy_to_user(arg, &info, sizeof(info)))
+1 -1
sound/firewire/fireface/ff-hwdep.c
··· 79 79 info.card = dev->card->index; 80 80 *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]); 81 81 *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]); 82 - strlcpy(info.device_name, dev_name(&dev->device), 82 + strscpy(info.device_name, dev_name(&dev->device), 83 83 sizeof(info.device_name)); 84 84 85 85 if (copy_to_user(arg, &info, sizeof(info)))
+1 -1
sound/firewire/fireworks/fireworks_hwdep.c
··· 212 212 info.card = dev->card->index; 213 213 *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]); 214 214 *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]); 215 - strlcpy(info.device_name, dev_name(&dev->device), 215 + strscpy(info.device_name, dev_name(&dev->device), 216 216 sizeof(info.device_name)); 217 217 218 218 if (copy_to_user(arg, &info, sizeof(info)))
+1 -1
sound/firewire/motu/motu-hwdep.c
··· 86 86 info.card = dev->card->index; 87 87 *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]); 88 88 *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]); 89 - strlcpy(info.device_name, dev_name(&dev->device), 89 + strscpy(info.device_name, dev_name(&dev->device), 90 90 sizeof(info.device_name)); 91 91 92 92 if (copy_to_user(arg, &info, sizeof(info)))
+1 -1
sound/firewire/oxfw/oxfw-hwdep.c
··· 79 79 info.card = dev->card->index; 80 80 *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]); 81 81 *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]); 82 - strlcpy(info.device_name, dev_name(&dev->device), 82 + strscpy(info.device_name, dev_name(&dev->device), 83 83 sizeof(info.device_name)); 84 84 85 85 if (copy_to_user(arg, &info, sizeof(info)))
+1 -1
sound/firewire/tascam/tascam-hwdep.c
··· 154 154 info.card = dev->card->index; 155 155 *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]); 156 156 *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]); 157 - strlcpy(info.device_name, dev_name(&dev->device), 157 + strscpy(info.device_name, dev_name(&dev->device), 158 158 sizeof(info.device_name)); 159 159 160 160 if (copy_to_user(arg, &info, sizeof(info)))
+2 -2
sound/i2c/i2c.c
··· 84 84 list_add_tail(&bus->buses, &master->buses); 85 85 bus->master = master; 86 86 } 87 - strlcpy(bus->name, name, sizeof(bus->name)); 87 + strscpy(bus->name, name, sizeof(bus->name)); 88 88 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &ops); 89 89 if (err < 0) { 90 90 snd_i2c_bus_free(bus); ··· 108 108 if (device == NULL) 109 109 return -ENOMEM; 110 110 device->addr = addr; 111 - strlcpy(device->name, name, sizeof(device->name)); 111 + strscpy(device->name, name, sizeof(device->name)); 112 112 list_add_tail(&device->list, &bus->devices); 113 113 device->bus = bus; 114 114 *rdevice = device;
+2 -2
sound/isa/ad1848/ad1848.c
··· 95 95 if (error < 0) 96 96 goto out; 97 97 98 - strlcpy(card->driver, "AD1848", sizeof(card->driver)); 99 - strlcpy(card->shortname, chip->pcm->name, sizeof(card->shortname)); 98 + strscpy(card->driver, "AD1848", sizeof(card->driver)); 99 + strscpy(card->shortname, chip->pcm->name, sizeof(card->shortname)); 100 100 101 101 if (!thinkpad[n]) 102 102 snprintf(card->longname, sizeof(card->longname),
+2 -2
sound/isa/cs423x/cs4231.c
··· 95 95 if (error < 0) 96 96 goto out; 97 97 98 - strlcpy(card->driver, "CS4231", sizeof(card->driver)); 99 - strlcpy(card->shortname, chip->pcm->name, sizeof(card->shortname)); 98 + strscpy(card->driver, "CS4231", sizeof(card->driver)); 99 + strscpy(card->shortname, chip->pcm->name, sizeof(card->shortname)); 100 100 101 101 if (dma2[n] < 0) 102 102 snprintf(card->longname, sizeof(card->longname),
+2 -2
sound/isa/cs423x/cs4236.c
··· 405 405 if (err < 0) 406 406 return err; 407 407 } 408 - strlcpy(card->driver, chip->pcm->name, sizeof(card->driver)); 409 - strlcpy(card->shortname, chip->pcm->name, sizeof(card->shortname)); 408 + strscpy(card->driver, chip->pcm->name, sizeof(card->driver)); 409 + strscpy(card->shortname, chip->pcm->name, sizeof(card->shortname)); 410 410 if (dma2[dev] < 0) 411 411 snprintf(card->longname, sizeof(card->longname), 412 412 "%s at 0x%lx, irq %i, dma %i",
+2 -2
sound/isa/es1688/es1688.c
··· 133 133 if (error < 0) 134 134 return error; 135 135 136 - strlcpy(card->driver, "ES1688", sizeof(card->driver)); 137 - strlcpy(card->shortname, chip->pcm->name, sizeof(card->shortname)); 136 + strscpy(card->driver, "ES1688", sizeof(card->driver)); 137 + strscpy(card->shortname, chip->pcm->name, sizeof(card->shortname)); 138 138 snprintf(card->longname, sizeof(card->longname), 139 139 "%s at 0x%lx, irq %i, dma %i", chip->pcm->name, chip->port, 140 140 chip->irq, chip->dma8);
+1 -1
sound/isa/sb/sb16_csp.c
··· 388 388 return err; 389 389 390 390 /* fill in codec header */ 391 - strlcpy(p->codec_name, info.codec_name, sizeof(p->codec_name)); 391 + strscpy(p->codec_name, info.codec_name, sizeof(p->codec_name)); 392 392 p->func_nr = func_nr; 393 393 p->mode = le16_to_cpu(funcdesc_h.flags_play_rec); 394 394 switch (le16_to_cpu(funcdesc_h.VOC_type)) {
+1 -1
sound/isa/sb/sb_mixer.c
··· 482 482 ctl = snd_ctl_new1(&newctls[type], chip); 483 483 if (! ctl) 484 484 return -ENOMEM; 485 - strlcpy(ctl->id.name, name, sizeof(ctl->id.name)); 485 + strscpy(ctl->id.name, name, sizeof(ctl->id.name)); 486 486 ctl->id.index = index; 487 487 ctl->private_value = value; 488 488 if ((err = snd_ctl_add(chip->card, ctl)) < 0)
+2 -2
sound/oss/dmasound/dmasound_core.c
··· 355 355 { 356 356 mixer_info info; 357 357 memset(&info, 0, sizeof(info)); 358 - strlcpy(info.id, dmasound.mach.name2, sizeof(info.id)); 359 - strlcpy(info.name, dmasound.mach.name2, sizeof(info.name)); 358 + strscpy(info.id, dmasound.mach.name2, sizeof(info.id)); 359 + strscpy(info.name, dmasound.mach.name2, sizeof(info.name)); 360 360 info.modify_counter = mixer.modify_counter; 361 361 if (copy_to_user((void __user *)arg, &info, sizeof(info))) 362 362 return -EFAULT;
+2 -2
sound/pci/cs5535audio/cs5535audio_olpc.c
··· 158 158 /* drop the original AD1888 HPF control */ 159 159 memset(&elem, 0, sizeof(elem)); 160 160 elem.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 161 - strlcpy(elem.name, "High Pass Filter Enable", sizeof(elem.name)); 161 + strscpy(elem.name, "High Pass Filter Enable", sizeof(elem.name)); 162 162 snd_ctl_remove_id(card, &elem); 163 163 164 164 /* drop the original V_REFOUT control */ 165 165 memset(&elem, 0, sizeof(elem)); 166 166 elem.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 167 - strlcpy(elem.name, "V_REFOUT Enable", sizeof(elem.name)); 167 + strscpy(elem.name, "V_REFOUT Enable", sizeof(elem.name)); 168 168 snd_ctl_remove_id(card, &elem); 169 169 170 170 /* add the OLPC-specific controls */
+1 -1
sound/pci/ctxfi/ctpcm.c
··· 433 433 pcm->private_data = atc; 434 434 pcm->info_flags = 0; 435 435 pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX; 436 - strlcpy(pcm->name, device_name, sizeof(pcm->name)); 436 + strscpy(pcm->name, device_name, sizeof(pcm->name)); 437 437 438 438 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ct_pcm_playback_ops); 439 439
+2 -2
sound/pci/emu10k1/emu10k1.c
··· 168 168 } 169 169 #endif 170 170 171 - strlcpy(card->driver, emu->card_capabilities->driver, 171 + strscpy(card->driver, emu->card_capabilities->driver, 172 172 sizeof(card->driver)); 173 - strlcpy(card->shortname, emu->card_capabilities->name, 173 + strscpy(card->shortname, emu->card_capabilities->name, 174 174 sizeof(card->shortname)); 175 175 snprintf(card->longname, sizeof(card->longname), 176 176 "%s (rev.%d, serial:0x%x) at 0x%lx, irq %i",
+1 -1
sound/pci/emu10k1/emu10k1_main.c
··· 1869 1869 emu->serial); 1870 1870 1871 1871 if (!*card->id && c->id) 1872 - strlcpy(card->id, c->id, sizeof(card->id)); 1872 + strscpy(card->id, c->id, sizeof(card->id)); 1873 1873 1874 1874 is_audigy = emu->audigy = c->emu10k2_chip; 1875 1875
+3 -3
sound/pci/emu10k1/emufx.c
··· 940 940 memset(gctl, 0, sizeof(*gctl)); 941 941 id = &ctl->kcontrol->id; 942 942 gctl->id.iface = (__force int)id->iface; 943 - strlcpy(gctl->id.name, id->name, sizeof(gctl->id.name)); 943 + strscpy(gctl->id.name, id->name, sizeof(gctl->id.name)); 944 944 gctl->id.index = id->index; 945 945 gctl->id.device = id->device; 946 946 gctl->id.subdevice = id->subdevice; ··· 976 976 err = snd_emu10k1_verify_controls(emu, icode, in_kernel); 977 977 if (err < 0) 978 978 goto __error; 979 - strlcpy(emu->fx8010.name, icode->name, sizeof(emu->fx8010.name)); 979 + strscpy(emu->fx8010.name, icode->name, sizeof(emu->fx8010.name)); 980 980 /* stop FX processor - this may be dangerous, but it's better to miss 981 981 some samples than generate wrong ones - [jk] */ 982 982 if (emu->audigy) ··· 1015 1015 int err; 1016 1016 1017 1017 mutex_lock(&emu->fx8010.lock); 1018 - strlcpy(icode->name, emu->fx8010.name, sizeof(icode->name)); 1018 + strscpy(icode->name, emu->fx8010.name, sizeof(icode->name)); 1019 1019 /* ok, do the main job */ 1020 1020 err = snd_emu10k1_gpr_peek(emu, icode); 1021 1021 if (err >= 0)
+1 -1
sound/pci/es1968.c
··· 2768 2768 if (!snd_tea575x_init(&chip->tea, THIS_MODULE)) { 2769 2769 dev_info(card->dev, "detected TEA575x radio type %s\n", 2770 2770 get_tea575x_gpio(chip)->name); 2771 - strlcpy(chip->tea.card, get_tea575x_gpio(chip)->name, 2771 + strscpy(chip->tea.card, get_tea575x_gpio(chip)->name, 2772 2772 sizeof(chip->tea.card)); 2773 2773 break; 2774 2774 }
+1 -1
sound/pci/fm801.c
··· 1300 1300 chip->tea575x_tuner |= tuner_only; 1301 1301 } 1302 1302 if (!(chip->tea575x_tuner & TUNER_DISABLED)) { 1303 - strlcpy(chip->tea.card, get_tea575x_gpio(chip)->name, 1303 + strscpy(chip->tea.card, get_tea575x_gpio(chip)->name, 1304 1304 sizeof(chip->tea.card)); 1305 1305 } 1306 1306 #endif
+1 -1
sound/pci/hda/hda_auto_parser.c
··· 764 764 } 765 765 if (!name) 766 766 return 0; 767 - strlcpy(label, name, maxlen); 767 + strscpy(label, name, maxlen); 768 768 return 1; 769 769 } 770 770 EXPORT_SYMBOL_GPL(snd_hda_get_pin_label);
+1 -1
sound/pci/hda/hda_codec.c
··· 4009 4009 sizeof(imux->items[imux->num_items].label), 4010 4010 "%s %d", label, label_idx); 4011 4011 else 4012 - strlcpy(imux->items[imux->num_items].label, label, 4012 + strscpy(imux->items[imux->num_items].label, label, 4013 4013 sizeof(imux->items[imux->num_items].label)); 4014 4014 imux->items[imux->num_items].index = index; 4015 4015 imux->num_items++;
+1 -1
sound/pci/hda/hda_controller.c
··· 735 735 &pcm); 736 736 if (err < 0) 737 737 return err; 738 - strlcpy(pcm->name, cpcm->name, sizeof(pcm->name)); 738 + strscpy(pcm->name, cpcm->name, sizeof(pcm->name)); 739 739 apcm = kzalloc(sizeof(*apcm), GFP_KERNEL); 740 740 if (apcm == NULL) { 741 741 snd_device_free(chip->card, pcm);
+1 -1
sound/pci/hda/hda_eld.c
··· 260 260 codec_info(codec, "HDMI: out of range MNL %d\n", mnl); 261 261 goto out_fail; 262 262 } else 263 - strlcpy(e->monitor_name, buf + ELD_FIXED_BYTES, mnl + 1); 263 + strscpy(e->monitor_name, buf + ELD_FIXED_BYTES, mnl + 1); 264 264 265 265 for (i = 0; i < e->sad_count; i++) { 266 266 if (ELD_FIXED_BYTES + mnl + 3 * (i + 1) > size) {
+1 -1
sound/pci/hda/hda_generic.c
··· 5721 5721 5722 5722 if (*str) 5723 5723 return; 5724 - strlcpy(str, chip_name, len); 5724 + strscpy(str, chip_name, len); 5725 5725 5726 5726 /* drop non-alnum chars after a space */ 5727 5727 for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
+1 -1
sound/pci/hda/hda_intel.c
··· 2037 2037 return -EBUSY; 2038 2038 2039 2039 strcpy(card->driver, "HDA-Intel"); 2040 - strlcpy(card->shortname, driver_short_names[chip->driver_type], 2040 + strscpy(card->shortname, driver_short_names[chip->driver_type], 2041 2041 sizeof(card->shortname)); 2042 2042 snprintf(card->longname, sizeof(card->longname), 2043 2043 "%s at 0x%lx irq %i",
+1 -1
sound/pci/hda/hda_jack.c
··· 530 530 !is_jack_detectable(codec, nid); 531 531 532 532 if (base_name) 533 - strlcpy(name, base_name, sizeof(name)); 533 + strscpy(name, base_name, sizeof(name)); 534 534 else 535 535 snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), NULL); 536 536 if (phantom_jack)
+1 -1
sound/pci/ice1712/juli.c
··· 413 413 { 414 414 struct snd_ctl_elem_id sid = {0}; 415 415 416 - strlcpy(sid.name, name, sizeof(sid.name)); 416 + strscpy(sid.name, name, sizeof(sid.name)); 417 417 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 418 418 return snd_ctl_find_id(card, &sid); 419 419 }
+2 -2
sound/pci/ice1712/psc724.c
··· 189 189 /* notify about master speaker mute change */ 190 190 memset(&elem_id, 0, sizeof(elem_id)); 191 191 elem_id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 192 - strlcpy(elem_id.name, "Master Speakers Playback Switch", 192 + strscpy(elem_id.name, "Master Speakers Playback Switch", 193 193 sizeof(elem_id.name)); 194 194 kctl = snd_ctl_find_id(ice->card, &elem_id); 195 195 snd_ctl_notify(ice->card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id); 196 196 /* and headphone mute change */ 197 - strlcpy(elem_id.name, spec->wm8776.ctl[WM8776_CTL_HP_SW].name, 197 + strscpy(elem_id.name, spec->wm8776.ctl[WM8776_CTL_HP_SW].name, 198 198 sizeof(elem_id.name)); 199 199 kctl = snd_ctl_find_id(ice->card, &elem_id); 200 200 snd_ctl_notify(ice->card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);
+1 -1
sound/pci/ice1712/quartet.c
··· 771 771 { 772 772 struct snd_ctl_elem_id sid = {0}; 773 773 774 - strlcpy(sid.name, name, sizeof(sid.name)); 774 + strscpy(sid.name, name, sizeof(sid.name)); 775 775 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 776 776 return snd_ctl_find_id(card, &sid); 777 777 }
+1 -1
sound/pci/ice1712/wm8776.c
··· 38 38 unsigned int index_offset; 39 39 40 40 memset(&elem_id, 0, sizeof(elem_id)); 41 - strlcpy(elem_id.name, ctl_name, sizeof(elem_id.name)); 41 + strscpy(elem_id.name, ctl_name, sizeof(elem_id.name)); 42 42 elem_id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 43 43 kctl = snd_ctl_find_id(card, &elem_id); 44 44 if (!kctl)
+1 -1
sound/pci/lola/lola.c
··· 669 669 } 670 670 671 671 strcpy(card->driver, "Lola"); 672 - strlcpy(card->shortname, "Digigram Lola", sizeof(card->shortname)); 672 + strscpy(card->shortname, "Digigram Lola", sizeof(card->shortname)); 673 673 snprintf(card->longname, sizeof(card->longname), 674 674 "%s at 0x%lx irq %i", 675 675 card->shortname, chip->bar[0].addr, chip->irq);
+1 -1
sound/pci/lola/lola_pcm.c
··· 601 601 &pcm); 602 602 if (err < 0) 603 603 return err; 604 - strlcpy(pcm->name, "Digigram Lola", sizeof(pcm->name)); 604 + strscpy(pcm->name, "Digigram Lola", sizeof(pcm->name)); 605 605 pcm->private_data = chip; 606 606 for (i = 0; i < 2; i++) { 607 607 if (chip->pcm[i].num_streams)
+1 -1
sound/pci/rme9652/hdspm.c
··· 6329 6329 memset(&hdspm_version, 0, sizeof(hdspm_version)); 6330 6330 6331 6331 hdspm_version.card_type = hdspm->io_type; 6332 - strlcpy(hdspm_version.cardname, hdspm->card_name, 6332 + strscpy(hdspm_version.cardname, hdspm->card_name, 6333 6333 sizeof(hdspm_version.cardname)); 6334 6334 hdspm_version.serial = hdspm->serial; 6335 6335 hdspm_version.firmware_rev = hdspm->firmware_rev;
+1 -1
sound/ppc/keywest.c
··· 49 49 return -EINVAL; /* ignored */ 50 50 51 51 memset(&info, 0, sizeof(struct i2c_board_info)); 52 - strlcpy(info.type, "keywest", I2C_NAME_SIZE); 52 + strscpy(info.type, "keywest", I2C_NAME_SIZE); 53 53 info.addr = keywest_ctx->addr; 54 54 client = i2c_new_client_device(adapter, &info); 55 55 if (IS_ERR(client))
+1 -1
sound/soc/qcom/qdsp6/q6afe.c
··· 1707 1707 pkt->hdr.token = hw_block_id; 1708 1708 pkt->hdr.opcode = AFE_CMD_REMOTE_LPASS_CORE_HW_VOTE_REQUEST; 1709 1709 vote_cfg->hw_block_id = hw_block_id; 1710 - strlcpy(vote_cfg->client_name, client_name, 1710 + strscpy(vote_cfg->client_name, client_name, 1711 1711 sizeof(vote_cfg->client_name)); 1712 1712 1713 1713 ret = afe_apr_send_pkt(afe, pkt, NULL,
+1 -1
sound/soc/sh/rcar/core.c
··· 1472 1472 uinfo->value.enumerated.items = cfg->max; 1473 1473 if (uinfo->value.enumerated.item >= cfg->max) 1474 1474 uinfo->value.enumerated.item = cfg->max - 1; 1475 - strlcpy(uinfo->value.enumerated.name, 1475 + strscpy(uinfo->value.enumerated.name, 1476 1476 cfg->texts[uinfo->value.enumerated.item], 1477 1477 sizeof(uinfo->value.enumerated.name)); 1478 1478 } else {
+1 -1
sound/usb/bcd2000/bcd2000.c
··· 300 300 if (ret < 0) 301 301 return ret; 302 302 303 - strlcpy(rmidi->name, bcd2k->card->shortname, sizeof(rmidi->name)); 303 + strscpy(rmidi->name, bcd2k->card->shortname, sizeof(rmidi->name)); 304 304 305 305 rmidi->info_flags = SNDRV_RAWMIDI_INFO_DUPLEX; 306 306 rmidi->private_data = bcd2k;
+1 -1
sound/usb/caiaq/audio.c
··· 804 804 } 805 805 806 806 cdev->pcm->private_data = cdev; 807 - strlcpy(cdev->pcm->name, cdev->product_name, sizeof(cdev->pcm->name)); 807 + strscpy(cdev->pcm->name, cdev->product_name, sizeof(cdev->pcm->name)); 808 808 809 809 memset(cdev->sub_playback, 0, sizeof(cdev->sub_playback)); 810 810 memset(cdev->sub_capture, 0, sizeof(cdev->sub_capture));
+3 -3
sound/usb/caiaq/device.c
··· 477 477 usb_string(usb_dev, usb_dev->descriptor.iProduct, 478 478 cdev->product_name, CAIAQ_USB_STR_LEN); 479 479 480 - strlcpy(card->driver, MODNAME, sizeof(card->driver)); 481 - strlcpy(card->shortname, cdev->product_name, sizeof(card->shortname)); 482 - strlcpy(card->mixername, cdev->product_name, sizeof(card->mixername)); 480 + strscpy(card->driver, MODNAME, sizeof(card->driver)); 481 + strscpy(card->shortname, cdev->product_name, sizeof(card->shortname)); 482 + strscpy(card->mixername, cdev->product_name, sizeof(card->mixername)); 483 483 484 484 /* if the id was not passed as module option, fill it with a shortened 485 485 * version of the product string which does not contain any
+1 -1
sound/usb/caiaq/midi.c
··· 125 125 if (ret < 0) 126 126 return ret; 127 127 128 - strlcpy(rmidi->name, device->product_name, sizeof(rmidi->name)); 128 + strscpy(rmidi->name, device->product_name, sizeof(rmidi->name)); 129 129 130 130 rmidi->info_flags = SNDRV_RAWMIDI_INFO_DUPLEX; 131 131 rmidi->private_data = device;
+2 -2
sound/usb/card.c
··· 474 474 else if (quirk && quirk->product_name) 475 475 s = quirk->product_name; 476 476 if (s && *s) { 477 - strlcpy(card->shortname, s, sizeof(card->shortname)); 477 + strscpy(card->shortname, s, sizeof(card->shortname)); 478 478 return; 479 479 } 480 480 ··· 506 506 if (preset && preset->profile_name) 507 507 s = preset->profile_name; 508 508 if (s && *s) { 509 - strlcpy(card->longname, s, sizeof(card->longname)); 509 + strscpy(card->longname, s, sizeof(card->longname)); 510 510 return; 511 511 } 512 512
+3 -3
sound/usb/hiface/chip.c
··· 80 80 return ret; 81 81 } 82 82 83 - strlcpy(card->driver, DRIVER_NAME, sizeof(card->driver)); 83 + strscpy(card->driver, DRIVER_NAME, sizeof(card->driver)); 84 84 85 85 if (quirk && quirk->device_name) 86 - strlcpy(card->shortname, quirk->device_name, sizeof(card->shortname)); 86 + strscpy(card->shortname, quirk->device_name, sizeof(card->shortname)); 87 87 else 88 - strlcpy(card->shortname, "M2Tech generic audio", sizeof(card->shortname)); 88 + strscpy(card->shortname, "M2Tech generic audio", sizeof(card->shortname)); 89 89 90 90 strlcat(card->longname, card->shortname, sizeof(card->longname)); 91 91 len = strlcat(card->longname, " at ", sizeof(card->longname));
+1 -1
sound/usb/hiface/pcm.c
··· 594 594 pcm->private_data = rt; 595 595 pcm->private_free = hiface_pcm_free; 596 596 597 - strlcpy(pcm->name, "USB-SPDIF Audio", sizeof(pcm->name)); 597 + strscpy(pcm->name, "USB-SPDIF Audio", sizeof(pcm->name)); 598 598 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pcm_ops); 599 599 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, 600 600 NULL, 0, 0);
+6 -6
sound/usb/mixer.c
··· 1556 1556 if (!found) 1557 1557 return; 1558 1558 1559 - strlcpy(kctl->id.name, "Headphone", sizeof(kctl->id.name)); 1559 + strscpy(kctl->id.name, "Headphone", sizeof(kctl->id.name)); 1560 1560 } 1561 1561 1562 1562 static const struct usb_feature_control_info *get_feature_control_info(int control) ··· 1691 1691 break; 1692 1692 default: 1693 1693 if (!len) 1694 - strlcpy(kctl->id.name, audio_feature_info[control-1].name, 1694 + strscpy(kctl->id.name, audio_feature_info[control-1].name, 1695 1695 sizeof(kctl->id.name)); 1696 1696 break; 1697 1697 } ··· 1770 1770 int name_len = get_term_name(mixer->chip, term, name, name_size, 0); 1771 1771 1772 1772 if (name_len == 0) 1773 - strlcpy(name, "Unknown", name_size); 1773 + strscpy(name, "Unknown", name_size); 1774 1774 1775 1775 /* 1776 1776 * sound/core/ctljack.c has a convention of naming jack controls ··· 2490 2490 if (check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name))) { 2491 2491 /* nothing */ ; 2492 2492 } else if (info->name) { 2493 - strlcpy(kctl->id.name, info->name, sizeof(kctl->id.name)); 2493 + strscpy(kctl->id.name, info->name, sizeof(kctl->id.name)); 2494 2494 } else { 2495 2495 if (extension_unit) 2496 2496 nameid = uac_extension_unit_iExtension(desc, state->mixer->protocol); ··· 2503 2503 kctl->id.name, 2504 2504 sizeof(kctl->id.name)); 2505 2505 if (!len) 2506 - strlcpy(kctl->id.name, name, sizeof(kctl->id.name)); 2506 + strscpy(kctl->id.name, name, sizeof(kctl->id.name)); 2507 2507 } 2508 2508 append_ctl_name(kctl, " "); 2509 2509 append_ctl_name(kctl, valinfo->suffix); ··· 2743 2743 kctl->id.name, sizeof(kctl->id.name), 0); 2744 2744 /* ... or use the fixed string "USB" as the last resort */ 2745 2745 if (!len) 2746 - strlcpy(kctl->id.name, "USB", sizeof(kctl->id.name)); 2746 + strscpy(kctl->id.name, "USB", sizeof(kctl->id.name)); 2747 2747 2748 2748 /* and add the proper suffix */ 2749 2749 if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR ||
+1 -1
sound/usb/mixer_quirks.c
··· 2725 2725 if (info->value.enumerated.item >= count) 2726 2726 info->value.enumerated.item = count - 1; 2727 2727 name = group->options[info->value.enumerated.item].name; 2728 - strlcpy(info->value.enumerated.name, name, sizeof(info->value.enumerated.name)); 2728 + strscpy(info->value.enumerated.name, name, sizeof(info->value.enumerated.name)); 2729 2729 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2730 2730 info->count = 1; 2731 2731 info->value.enumerated.items = count;
+1 -1
sound/usb/mixer_scarlett.c
··· 569 569 } 570 570 kctl->private_free = snd_usb_mixer_elem_free; 571 571 572 - strlcpy(kctl->id.name, name, sizeof(kctl->id.name)); 572 + strscpy(kctl->id.name, name, sizeof(kctl->id.name)); 573 573 574 574 err = snd_usb_mixer_add_control(&elem->head, kctl); 575 575 if (err < 0)
+1 -1
sound/usb/mixer_scarlett_gen2.c
··· 961 961 } 962 962 kctl->private_free = snd_usb_mixer_elem_free; 963 963 964 - strlcpy(kctl->id.name, name, sizeof(kctl->id.name)); 964 + strscpy(kctl->id.name, name, sizeof(kctl->id.name)); 965 965 966 966 err = snd_usb_mixer_add_control(&elem->head, kctl); 967 967 if (err < 0)
+1 -1
sound/usb/mixer_us16x08.c
··· 1076 1076 else 1077 1077 kctl->private_free = snd_usb_mixer_elem_free; 1078 1078 1079 - strlcpy(kctl->id.name, name, sizeof(kctl->id.name)); 1079 + strscpy(kctl->id.name, name, sizeof(kctl->id.name)); 1080 1080 1081 1081 err = snd_usb_mixer_add_control(&elem->head, kctl); 1082 1082 if (err < 0)
+1 -1
sound/x86/intel_hdmi_audio.c
··· 1790 1790 /* setup private data which can be retrieved when required */ 1791 1791 pcm->private_data = ctx; 1792 1792 pcm->info_flags = 0; 1793 - strlcpy(pcm->name, card->shortname, strlen(card->shortname)); 1793 + strscpy(pcm->name, card->shortname, strlen(card->shortname)); 1794 1794 /* setup the ops for playabck */ 1795 1795 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &had_pcm_ops); 1796 1796
+1 -1
sound/xen/xen_snd_front_cfg.c
··· 398 398 399 399 str = xenbus_read(XBT_NIL, device_path, XENSND_FIELD_DEVICE_NAME, NULL); 400 400 if (!IS_ERR(str)) { 401 - strlcpy(pcm_instance->name, str, sizeof(pcm_instance->name)); 401 + strscpy(pcm_instance->name, str, sizeof(pcm_instance->name)); 402 402 kfree(str); 403 403 } 404 404