7010 2014-12-02 13:42:59 +0000 systemd-serialgetty cannot create a serial-getty@.service that is not enabled 2022-01-07 20:38:33 +0000 1 1 7 Build System, Metadata & Runtime OE-Core core 1.7 All Multiple RESOLVED WORKSFORME Medium normal 3.3 M2 1 jbb5044 jbb5044 liezhi.yang meta.mr.watcher meta.watcher randy.macleod sgw --- --- Yes (doc changes required) oldest_to_newest 47288 0 2270 jbb5044 2014-12-02 13:42:59 +0000 Created attachment 2270 Patch to add support for creating serial-getty service files without enabling them While setting up a commercial embedded system using yocto, we wanted the ability to start a serial-getty@.service unit when triggered with a special engineering-only mechanism, but not on a normal boot. We wanted the serial-getty@.service file to be created, but not enabled in systemd. Setting the SERIAL_CONSOLES line in the machine.conf to an empty string simply resulted in _no_ serial-getty@.service files being created. Looking at the systemd-serialgetty.bb file, I can see that the current do_install() does not have any means to specify only the bauderate of the serial port and not enable it by default. I attached the solution I use. Allow the SERIAL_CONSOLES variable to be set to _just_ the bauderate. In systemd-serialgetty.bb, modify the sed command that extracts the serial port path so that it returns an empty string instead of the bauderate in this case, then add a simple if block to only enable the serial port if the serial path is not empty. Attached patch is on top of the dizzy branch made with git format-patch. If accepted, documentation for the SERIAL_CONSOLES would need to be updated. 85443 1 Qi.Chen 2019-10-25 01:10:51 +0000 Does Jason's recent change to serialgetty solve such problem in another direction? commit eddbd0c3145156559b9fe004508af6da27e379cb Author: Jason Wessel <jason.wessel@windriver.com> Date: Thu Aug 29 07:00:31 2019 -0700 serial-getty@.service: Allow device to fast fail if it does not exist Some BSPs use a USB serial port which may or may not actually be plugged all the time. It is quite useful to have a USB serial port have a getty running but it does not make sense to wait for it for 90 seconds before completing the system startup if it might never get plugged in. The typical example is that a USB serial device might only need to be plugged in when debugging, upgrading, or initially configuring a device. This change is somewhat subtle. Systemd uses the "BindsTo" directive to ensure existence of the device in order to start the service as well as to terminate the service if the device goes away. The "After" directive makes that same relationship stronger. When used together this has the undesired side effect that systemd will wait until its internal time out value of 90 seconds for the device to come on line before executing a fail operation or letting other tasks and groups continue. This is certainly the kind of behavior we want for a disk, but not for serial ports in general. The "BindsTo" directive is replaced by the combination of the "PartOf" and the "ConditionPathExists" directives. The "After" directive is unchanged because that will wait for the udev rules to process. The "PartOf" directive will issue a stop to the getty service if the device goes away, similar to the "BindsTo" directive. The "ConditionPathExists" is what allows the service to fail fast vs waiting for the timeout. When a USB device is not plugged in at boot you would find a message in the system journal like: systemd[1]: Condition check resulted in Serial Getty on \ ttyUSB0 being skipped. If you want to observe the problem with qemu, it is easy to replicate. Simply add the following line to your local.conf for a x86-64 qemu build. SERIAL_CONSOLES="115200;ttyS0 115200;ttyUSB0" 88495 2 Qi.Chen 2020-10-27 00:32:45 +0000 (In reply to comment #0) > Created attachment 2270 [details] > Patch to add support for creating serial-getty service files without > enabling them > > While setting up a commercial embedded system using yocto, we wanted the > ability to start a serial-getty@.service unit when triggered with a special > engineering-only mechanism, but not on a normal boot. We wanted the > serial-getty@.service file to be created, but not enabled in systemd. > Setting the SERIAL_CONSOLES line in the machine.conf to an empty string > simply resulted in _no_ serial-getty@.service files being created. Looking > at the systemd-serialgetty.bb file, I can see that the current do_install() > does not have any means to specify only the bauderate of the serial port and > not enable it by default. > > I attached the solution I use. Allow the SERIAL_CONSOLES variable to be set > to _just_ the bauderate. In systemd-serialgetty.bb, modify the sed command > that extracts the serial port path so that it returns an empty string > instead of the bauderate in this case, then add a simple if block to only > enable the serial port if the serial path is not empty. > > Attached patch is on top of the dizzy branch made with git format-patch. > > If accepted, documentation for the SERIAL_CONSOLES would need to be updated. Hi Joe, Please check if Jason's patch would solve your problem in another direction. If not, you can send out patch to oe-core mailing list. 88497 3 randy.macleod 2020-10-27 07:58:59 +0000 Joe, Please comment on Jason's patch. 88656 4 jbb5044 2020-11-21 16:12:09 +0000 I unfortunately do not use Yocto on a day-to-day basis so this bug no longer affects me. Jason's patch would work for me. 2270 2014-12-02 13:42:59 +0000 2014-12-02 13:42:59 +0000 Patch to add support for creating serial-getty service files without enabling them 0001-systemd-serialgetty.bb-Allow-non-enabled-serial-gett.patch text/plain 3009 jbb5044 RnJvbSAwYjcxMTFlNjM4M2EzNjEzZDY3ZTc5YmQzYmIxNGVkMDI0YzFhYzk4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb2UgQmFsb3VnaCA8amJiNTA0NEBnbWFpbC5jb20+CkRhdGU6 IFR1ZSwgMiBEZWMgMjAxNCAwODozNjo1MyAtMDUwMApTdWJqZWN0OiBbUEFUQ0hdIHN5c3RlbWQt c2VyaWFsZ2V0dHkuYmI6IEFsbG93IG5vbi1lbmFibGVkCiBzZXJpYWwtZ2V0dHlALnNlcnZpY2Ug ZmlsZXMKClByZXZpb3VzIGltcGxlbWVudGF0aW9uIGF1dG9tYXRpY2FsbHkgZW5hYmxlZCBhbGwg c2VyaWFsLWdldHR5QC5zZXJ2aWNlCmZpbGVzIGFzIHNwZWNpZmllZCBpbiB0aGUgU0VSSUFMX0NP TlNPTEUgdmFyaWFibGUgd2l0aCBubyB3YXkgdG8gc2ltcGx5CmNyZWF0ZSBhIHNlcmlhbC1nZXR0 eUAuc2VydmljZSBmaWxlIHdpdGhvdXQgZW5hYmxpbmcgaXQuCgpBbGxvdyBjcmVhdGluZyBvbmx5 IHRoZSBzZXJpYWwtZ2V0dHlALnNlcnZpY2UgZmlsZSB3aXRob3V0IGVuYWJsaW5nIGl0CndoZW4g dGhlIFNFUklBTF9DT05TT0xFIHZhcmlhYmxlIGlzIHNpbXBseSBzZXQgdG8gdGhlIHNlcmlhbCBw b3J0J3MKYmF1ZGVyYXRlLgpNb2RpZnkgc2VkIGNvbW1hbmQgdGhhdCBleHRyYWN0cyB0dHlkZXYg c2xpZ2h0bHkgc28gdGhhdCBpdCBvbmx5IHByaW50cwppZiB0aGUgcmVwbGFjZW1lbnQgaGFwcGVu ZWQuIFRoaXMgd2lsbCBjYXVzZSB0aGUgdHR5ZGV2IHZhcmlhYmxlIHRvIGJlCmFuIGVtcHR5IHN0 cmluZyBpZiBpdCBjb250YWlucyBvbmx5IHRoZSBiYXVkZXJhdGUsIHRoZW4gb25seSBlbmFibGUg dGhlCnNlcnZpY2UgaWYgdGhlIHR0eWRldiB2YXJpYWJsZSBpcyBub3QgZW1wdHkuCi0tLQogbWV0 YS9yZWNpcGVzLWNvcmUvc3lzdGVtZC9zeXN0ZW1kLXNlcmlhbGdldHR5LmJiIHwgMjYgKysrKysr KysrKysrKy0tLS0tLS0tLS0tCiAxIGZpbGUgY2hhbmdlZCwgMTQgaW5zZXJ0aW9ucygrKSwgMTIg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvbWV0YS9yZWNpcGVzLWNvcmUvc3lzdGVtZC9zeXN0 ZW1kLXNlcmlhbGdldHR5LmJiIGIvbWV0YS9yZWNpcGVzLWNvcmUvc3lzdGVtZC9zeXN0ZW1kLXNl cmlhbGdldHR5LmJiCmluZGV4IDFjMzRkNWMuLmE5NGQ3ZWIgMTAwNjQ0Ci0tLSBhL21ldGEvcmVj aXBlcy1jb3JlL3N5c3RlbWQvc3lzdGVtZC1zZXJpYWxnZXR0eS5iYgorKysgYi9tZXRhL3JlY2lw ZXMtY29yZS9zeXN0ZW1kL3N5c3RlbWQtc2VyaWFsZ2V0dHkuYmIKQEAgLTE5LDE4ICsxOSwyMCBA QCBkb19pbnN0YWxsKCkgewogCQl0bXA9IiR7U0VSSUFMX0NPTlNPTEVTfSIKIAkJZm9yIGVudHJ5 IGluICR0bXAgOyBkbwogCQkJYmF1ZHJhdGU9YGVjaG8gJGVudHJ5IHwgc2VkICdzL1w7LiovLydg Ci0JCQl0dHlkZXY9YGVjaG8gJGVudHJ5IHwgc2VkIC1lICdzL15bMC05XSpcOy8vJyAtZSAncy9c Oy4qLy8nYAotCQkJaWYgWyAiJGJhdWRyYXRlIiA9ICIkZGVmYXVsdF9iYXVkcmF0ZSIgXSA7IHRo ZW4KLQkJCQkjIGVuYWJsZSB0aGUgc2VydmljZQotCQkJCWxuIC1zZiAke3N5c3RlbWRfdW5pdGRp cn0vc3lzdGVtL3NlcmlhbC1nZXR0eUAuc2VydmljZSBcCi0JCQkJCSR7RH0ke3N5c2NvbmZkaXJ9 L3N5c3RlbWQvc3lzdGVtL2dldHR5LnRhcmdldC53YW50cy9zZXJpYWwtZ2V0dHlAJHR0eWRldi5z ZXJ2aWNlCi0JCQllbHNlCi0JCQkJIyBpbnN0YWxsIGN1c3RvbSBzZXJ2aWNlIGZpbGUgZm9yIHRo ZSBub24tZGVmYXVsdCBiYXVkcmF0ZQotCQkJCWluc3RhbGwgLW0gMDY0NCAke1dPUktESVJ9L3Nl cmlhbC1nZXR0eUAuc2VydmljZSAke0R9JHtzeXN0ZW1kX3VuaXRkaXJ9L3N5c3RlbS9zZXJpYWwt Z2V0dHkkYmF1ZHJhdGVALnNlcnZpY2UKLQkJCQlzZWQgLWkgLWUgcy9cQEJBVURSQVRFXEAvJGJh dWRyYXRlL2cgJHtEfSR7c3lzdGVtZF91bml0ZGlyfS9zeXN0ZW0vc2VyaWFsLWdldHR5JGJhdWRy YXRlQC5zZXJ2aWNlCi0JCQkJIyBlbmFibGUgdGhlIHNlcnZpY2UKLQkJCQlsbiAtc2YgJHtzeXN0 ZW1kX3VuaXRkaXJ9L3N5c3RlbS9zZXJpYWwtZ2V0dHkkYmF1ZHJhdGVALnNlcnZpY2UgXAotCQkJ CQkke0R9JHtzeXNjb25mZGlyfS9zeXN0ZW1kL3N5c3RlbS9nZXR0eS50YXJnZXQud2FudHMvc2Vy aWFsLWdldHR5JGJhdWRyYXRlQCR0dHlkZXYuc2VydmljZQorCQkJdHR5ZGV2PWBlY2hvICRlbnRy eSB8IHNlZCAtbiAtZSAncy9eWzAtOV0qXDsvL3AnIC1lICdzL1w7LiovL3AnYAorCQkJaWYgWyAh IC16ICIke3R0eWRldn0iIF0gOyB0aGVuCisJCQkJaWYgWyAiJGJhdWRyYXRlIiA9ICIkZGVmYXVs dF9iYXVkcmF0ZSIgXSA7IHRoZW4KKwkJCQkJIyBlbmFibGUgdGhlIHNlcnZpY2UKKwkJCQkJbG4g LXNmICR7c3lzdGVtZF91bml0ZGlyfS9zeXN0ZW0vc2VyaWFsLWdldHR5QC5zZXJ2aWNlIFwKKwkJ CQkJCSR7RH0ke3N5c2NvbmZkaXJ9L3N5c3RlbWQvc3lzdGVtL2dldHR5LnRhcmdldC53YW50cy9z ZXJpYWwtZ2V0dHlAJHR0eWRldi5zZXJ2aWNlCisJCQkJZWxzZQorCQkJCQkjIGluc3RhbGwgY3Vz dG9tIHNlcnZpY2UgZmlsZSBmb3IgdGhlIG5vbi1kZWZhdWx0IGJhdWRyYXRlCisJCQkJCWluc3Rh bGwgLW0gMDY0NCAke1dPUktESVJ9L3NlcmlhbC1nZXR0eUAuc2VydmljZSAke0R9JHtzeXN0ZW1k X3VuaXRkaXJ9L3N5c3RlbS9zZXJpYWwtZ2V0dHkkYmF1ZHJhdGVALnNlcnZpY2UKKwkJCQkJc2Vk IC1pIC1lIHMvXEBCQVVEUkFURVxALyRiYXVkcmF0ZS9nICR7RH0ke3N5c3RlbWRfdW5pdGRpcn0v c3lzdGVtL3NlcmlhbC1nZXR0eSRiYXVkcmF0ZUAuc2VydmljZQorCQkJCQkjIGVuYWJsZSB0aGUg c2VydmljZQorCQkJCQlsbiAtc2YgJHtzeXN0ZW1kX3VuaXRkaXJ9L3N5c3RlbS9zZXJpYWwtZ2V0 dHkkYmF1ZHJhdGVALnNlcnZpY2UgXAorCQkJCQkJJHtEfSR7c3lzY29uZmRpcn0vc3lzdGVtZC9z eXN0ZW0vZ2V0dHkudGFyZ2V0LndhbnRzL3NlcmlhbC1nZXR0eSRiYXVkcmF0ZUAkdHR5ZGV2LnNl cnZpY2UKKwkJCQlmaQogCQkJZmkKIAkJZG9uZQogCWZpCi0tIAoyLjEuMgoK