Yana printfevresel değil, bir sinyal işleyici kullanmak için güvenli olması gerekiyordu değil. Ama kullanılan birçok örnek kod gördümprintf bu şekilde .
Öyleyse sorum şu: printfbir sinyal işleyicide kullanmaktan ne zaman kaçınmamız gerekiyor ve önerilen bir yedek var mı?
Yanıtlar:
Bazı bayrak değişkenlerini kullanabilir, bu bayrağı sinyal işleyicinin içinde ayarlayabilir ve bu bayrak çağrısı printf()işlevini main () veya normal çalışma sırasında programın başka bir bölümünde temel alabilirsiniz.
printfBir sinyal işleyicinin içinden olduğu gibi tüm işlevleri çağırmak güvenli değildir . Yararlı bir teknik, a'yı ayarlamak için bir sinyal işleyici kullanmakflagve bunuflagana programdan kontrol etmek ve gerekirse bir mesaj yazdırmaktır.
Aşağıdaki örnekte dikkat edin, sinyal işleyici ding () alarm_fired, SIGALRM yakalandığında bir bayrağı 1'e ayarladı ve ana işlevde alarm_fireddeğer, koşullu olarak printf'i doğru şekilde çağırmak için incelendi.
static int alarm_fired = 0;
void ding(int sig) // can be called asynchronously
{
alarm_fired = 1; // set flag
}
int main()
{
pid_t pid;
printf("alarm application starting\n");
pid = fork();
switch(pid) {
case -1:
/* Failure */
perror("fork failed");
exit(1);
case 0:
/* child */
sleep(5);
kill(getppid(), SIGALRM);
exit(0);
}
/* if we get here we are the parent process */
printf("waiting for alarm to go off\n");
(void) signal(SIGALRM, ding);
pause();
if (alarm_fired) // check flag to call printf
printf("Ding!\n");
printf("done\n");
exit(0);
}
Referans: Linux Programlamaya Başlamak, 4th Edition , Bu kitapta kodunuz tam olarak açıklanmıştır (ne isterseniz), Bölüm 11: İşlemler ve Sinyaller, sayfa 484
Ek olarak, işleyici işlevlerini yazarken özel dikkat göstermeniz gerekir çünkü bunlar eşzamansız olarak çağrılabilir. Yani, programın herhangi bir noktasında tahmin edilemeyen bir şekilde bir işleyici çağrılabilir. Çok kısa bir aralıkta iki sinyal gelirse, bir işleyici diğerinin içinde çalışabilir. Ve beyan etmek daha iyi bir uygulama olarak kabul edilir volatile sigatomic_t, bu tip her zaman atomik olarak erişilir, bir değişkene erişimi kesintiye uğratma konusundaki belirsizlikten kaçınır. ( Ayrıntılı açıklama için Atomik Veri Erişimi ve Sinyal İşleme'yi okuyun ).
Sinyal İşleyicileri Tanımlama : signal()veya sigaction()işlevleriyle kurulabilen bir sinyal işleyici işlevinin nasıl yazılacağını öğrenmek için okuyun . Kılavuz sayfasındaki
yetkili işlevlerin listesi, bu işlevi sinyal işleyici içinde çağırmak güvenlidir.
volatile sigatomic_t alarm_fired;
Birincil sorun, sinyal kesintiye uğrarsa malloc()veya benzer bir işlev görürse, dahili durumun, boş ve kullanılmış liste veya diğer benzer işlemler arasında bellek bloklarını hareket ettirirken geçici olarak tutarsız olabilmesidir. Sinyal işleyicideki kod daha sonra başlatan bir işlevi çağırırsa malloc(), bu bellek yönetimini tamamen mahvedebilir.
C standardı, bir sinyal işleyicide neler yapabileceğinize dair oldukça muhafazakar bir görüş alır:
ISO / IEC 9899: 2011 §7.14.1.1
signalİşlev¶5 Sinyal,
abortveyaraiseişlevinin çağrılmasının sonucu dışında meydana gelirse, sinyal işleyici statik veya iş parçacığı depolama süresi olan ve bir değer atama dışında kilit içermeyen atomik bir nesne olmayan herhangi bir nesneye başvurursa, davranış tanımsızdır. olarak bildirilen bir nesneyevolatile sig_atomic_tveya sinyal işleyici, standart kitaplıktaabortişlev,_Exitişlev,quick_exitişlev veya işlev dışında herhangi bir işlevi çağırırsignalve ilk bağımsız değişkenin çağrılmasına neden olan sinyale karşılık gelen sinyal numarasına eşittir. işleyici. Ayrıca,signalişlev için böyle bir çağrı birSIG_ERRdönüşle sonuçlanırsa , değerierrnobelirsizdir. 252)252) Eğer bir eşzamansız sinyal işleyici tarafından herhangi bir sinyal üretilirse, davranış tanımsızdır.
POSIX, bir sinyal işleyicide neler yapabileceğiniz konusunda çok daha cömerttir.
POSIX 2008 sürümündeki Signal Concepts şunları söylüyor:
İşlem çok iş parçacıklıysa veya işlem tek iş parçacıklıysa ve aşağıdakilerin sonucu dışında bir sinyal işleyici yürütülüyorsa:
İşlem arama
abort(),raise(),kill(),pthread_kill(), ya dasigqueue()engellenmeyen bir sinyal üretmek içinEngeli kaldırılan ve engelini kaldıran çağrı geri dönmeden önce iletilen bekleyen sinyal
Sinyal işleyici
errno, statik depolama süresi dışında herhangi bir nesneye atıfta bulunuyorsa, şu şekilde bildirilen bir nesneye bir değer atamak dışında davranış tanımsızdır .volatile sig_atomic_tveya sinyal işleyici, bu standartta tanımlanan işlevlerden biri dışında listelenen işlevlerden birini çağırıyorsa . aşağıdaki tablo.Aşağıdaki tablo, eşzamansız sinyal güvenli olacak bir dizi işlevi tanımlamaktadır. Bu nedenle, uygulamalar bunları sinyal yakalama işlevlerinden kısıtlama olmaksızın çağırabilir:
_Exit() fexecve() posix_trace_event() sigprocmask() _exit() fork() pselect() sigqueue() … fcntl() pipe() sigpause() write() fdatasync() poll() sigpending()Yukarıdaki tabloda yer almayan tüm işlevler, sinyaller açısından güvenli değildir. Sinyallerin varlığında, POSIX.1-2008'in bu hacmi tarafından tanımlanan tüm işlevler, tek bir istisna dışında, bir sinyal yakalama işlevinden çağrıldığında veya bu işlev tarafından kesintiye uğradığında tanımlandığı gibi davranacaktır: bir sinyal güvenli olmayan bir işlevi ve sinyal yakalama işlevi güvenli olmayan bir işlevi çağırır, davranış tanımsızdır.
Değeri elde eden
errnoişlemler ve bir değer atayan işlemlererrnoeşzamansız sinyal açısından güvenli olacaktır.Bir iş parçacığına bir sinyal iletildiğinde, bu sinyalin eylemi sonlandırma, durdurma veya devam etmeyi belirtiyorsa, tüm süreç sırasıyla sonlandırılacak, durdurulacak veya devam ettirilecektir.
Bununla birlikte, printf()işlevler ailesi bu listede özellikle yoktur ve bir sinyal işleyiciden güvenli bir şekilde çağrılmayabilir.
POSIX 2016 güncelleme dahil güvenli fonksiyonların listesini uzanır, özellikle, işlevlerin çok sayıda <string.h>, özellikle değerli bir katkı (ya da özel olarak sinir bozucu bir gözetim idi). Liste şimdi:
_Exit() getppid() sendmsg() tcgetpgrp()
_exit() getsockname() sendto() tcsendbreak()
abort() getsockopt() setgid() tcsetattr()
accept() getuid() setpgid() tcsetpgrp()
access() htonl() setsid() time()
aio_error() htons() setsockopt() timer_getoverrun()
aio_return() kill() setuid() timer_gettime()
aio_suspend() link() shutdown() timer_settime()
alarm() linkat() sigaction() times()
bind() listen() sigaddset() umask()
cfgetispeed() longjmp() sigdelset() uname()
cfgetospeed() lseek() sigemptyset() unlink()
cfsetispeed() lstat() sigfillset() unlinkat()
cfsetospeed() memccpy() sigismember() utime()
chdir() memchr() siglongjmp() utimensat()
chmod() memcmp() signal() utimes()
chown() memcpy() sigpause() wait()
clock_gettime() memmove() sigpending() waitpid()
close() memset() sigprocmask() wcpcpy()
connect() mkdir() sigqueue() wcpncpy()
creat() mkdirat() sigset() wcscat()
dup() mkfifo() sigsuspend() wcschr()
dup2() mkfifoat() sleep() wcscmp()
execl() mknod() sockatmark() wcscpy()
execle() mknodat() socket() wcscspn()
execv() ntohl() socketpair() wcslen()
execve() ntohs() stat() wcsncat()
faccessat() open() stpcpy() wcsncmp()
fchdir() openat() stpncpy() wcsncpy()
fchmod() pause() strcat() wcsnlen()
fchmodat() pipe() strchr() wcspbrk()
fchown() poll() strcmp() wcsrchr()
fchownat() posix_trace_event() strcpy() wcsspn()
fcntl() pselect() strcspn() wcsstr()
fdatasync() pthread_kill() strlen() wcstok()
fexecve() pthread_self() strncat() wmemchr()
ffs() pthread_sigmask() strncmp() wmemcmp()
fork() raise() strncpy() wmemcpy()
fstat() read() strnlen() wmemmove()
fstatat() readlink() strpbrk() wmemset()
fsync() readlinkat() strrchr() write()
ftruncate() recv() strspn()
futimens() recvfrom() strstr()
getegid() recvmsg() strtok_r()
geteuid() rename() symlink()
getgid() renameat() symlinkat()
getgroups() rmdir() tcdrain()
getpeername() select() tcflow()
getpgrp() sem_post() tcflush()
getpid() send() tcgetattr()
Sonuç olarak, ya et al write()tarafından sağlanan biçimlendirme desteği olmadan kullanırsınız ya da printf()kodunuzun uygun yerlerinde (periyodik olarak) test ettiğiniz bir bayrak oluşturursunuz. Bu teknik hünerle gösterilmiştir cevap tarafından Grijesh Chauhan .
chqrlie , kısmi bir cevabından fazlasına sahip olmadığım ilginç bir soru sorar :
Neden çoğu dizge işlevi
<string.h>veya karakter sınıfı işlevlerinden<ctype.h>ve daha birçok C standart kitaplık işlevi yukarıdaki listede yer almıyor? Bir uygulamanınstrlen(), bir sinyal işleyiciden aramayı güvensiz kılmak için kasıtlı olarak kötü olması gerekir .
İşlevlerin çoğu için <string.h>, niye ilan edilmedi zaman uyumsuz sinyal kasa görmek zor olduğunu ve hak verirdim strlen()birlikte bir örnektir strchr(), strstr()örneğin, vb Öte yandan, diğer fonksiyonlar strtok(), strcoll()ve strxfrm()oldukça karmaşıktır ve eşzamansız sinyal güvenli olma olasılığı düşüktür. Çünkü strtok()aramalar arasındaki durumu korur ve sinyal işleyici, kullanılan kodun bir kısmının strtok()karışıp karışmayacağını kolayca anlayamaz . strcoll()Ve strxfrm()işlevleri yerel duyarlı verilerle çalışmak ve yerel yükleme devlet ayarı her türlü kapsar.
Dan fonksiyonları (makrolar) <ctype.h>tüm yerel duyarlıdır ve bu nedenle aynı sorunlarla çalıştırabilir strcoll()ve strxfrm().
<math.h>Bir SIGFPE'den (kayan nokta istisnası) etkilenebildikleri için, matematiksel fonksiyonların neden eşzamansız sinyal güvenli olmadığını anlamakta zorlanıyorum , ancak bugünlerde bunlardan birini gördüğüm tek zaman tam sayı sıfıra bölüm. Benzer belirsizlik doğar <complex.h>, <fenv.h>ve <tgmath.h>.
İçindeki işlevlerden bazıları <stdlib.h>muaf tutulabilir - abs()örneğin. Diğerleri özellikle sorunludur malloc()ve aile en önemli örneklerdir.
POSIX ortamında kullanılan Standart C'deki (2011) diğer başlıklar için de benzer bir değerlendirme yapılabilir. (Standart C o kadar kısıtlayıcıdır ki, bunları saf bir Standart C ortamında analiz etmeye hiç ilgi yoktur.) 'Yerel ayara bağlı' olarak işaretlenenler güvensizdir çünkü yerel ayarları değiştirmek bellek tahsisi vb. Gerektirebilir.
<assert.h>- Muhtemelen güvenli değil<complex.h>- Muhtemelen güvenli<ctype.h> - Güvenli değil<errno.h> - Güvenli<fenv.h>- Muhtemelen güvenli değil<float.h> - İşlev yok<inttypes.h> - Yerel ayara duyarlı işlevler (güvenli değil)<iso646.h> - İşlev yok<limits.h> - İşlev yok<locale.h> - Yerel ayara duyarlı işlevler (güvenli değil)<math.h>- Muhtemelen güvenli<setjmp.h> - Güvenli değil<signal.h> - İzin verilir<stdalign.h> - İşlev yok<stdarg.h> - İşlev yok<stdatomic.h>- Muhtemelen güvenli, muhtemelen güvenli değil<stdbool.h> - İşlev yok<stddef.h> - İşlev yok<stdint.h> - İşlev yok<stdio.h> - Güvenli değil<stdlib.h> - Her şey güvenli değil (bazılarına izin verilir; bazılarına izin verilmez)<stdnoreturn.h> - İşlev yok<string.h> - Tamamen güvenli değil<tgmath.h>- Muhtemelen güvenli<threads.h>- Muhtemelen güvenli değil<time.h>- Yerel ayara bağlıdır (ancak time()açıkça izin verilir)<uchar.h> - Yerel ayara bağlı<wchar.h> - Yerel ayara bağlı<wctype.h> - Yerel ayara bağlıPOSIX başlıklarını analiz etmek… birçoğu olduğundan daha zordur ve bazı işlevler güvenli olabilir, ancak çoğu olmayacaktır… ama aynı zamanda daha basittir çünkü POSIX hangi işlevlerin eşzamansız sinyal güvenli olduğunu söyler (çoğu değil). Bir başlığın <pthread.h>üç güvenli işleve ve birçok güvensiz işleve sahip olduğuna dikkat edin .
Not: POSIX ortamındaki C işlevlerinin ve başlıklarının neredeyse tüm değerlendirmeleri yarı eğitimli bir tahmindir. Bir standartlar kurumundan kesin bir ifade vermenin anlamı yoktur.
<string.h>veya karakter sınıfı işlevi <ctype.h>ve daha birçok C standart kitaplık işlevi yukarıdaki listede yer almıyor? Bir uygulamanın strlen(), bir sinyal işleyiciden aramayı güvensiz kılmak için kasıtlı olarak kötü olması gerekir .
<ctype.h>, yerel ayara özgüdür ve sinyal bir yerel ayar işlevini kesintiye uğratırsa sorunlara neden olabilir, ancak yerel ayar yüklendikten sonra bunları kullanmak güvenli olmalıdır. Tahminimce, bazı karmaşık durumlarda, yerel verilerin yüklenmesi aşamalı olarak yapılabilir, bu da işlevleri <ctype.h>güvensiz hale getirir . Sonuç kalır: Şüphe duyduğunuzda çekimser kalın.
printfBir sinyal işleyicide kullanmaktan nasıl kaçınılır ?
Her zaman kaçının, diyecek ki: printf()Sinyal tutucularda kullanmayın .
En azından POSIX uyumlu sistemlerde write(STDOUT_FILENO, ...)bunun yerine kullanabilirsiniz printf(). Ancak biçimlendirme kolay olmayabilir: Yazma veya eşzamansız güvenlik işlevlerini kullanarak sinyal işleyiciden int yazdırın
Always avoid it.demek? Kaçınmak printf()mı?
printf()sinyal işleyicilerini ne zaman kullanmaktan kaçınması gerektiğini soruyordu .
2soran OP'ye bakın. printf()
Hata ayıklama amacıyla, aslında yalnızca async-signal-safelistedeki işlevleri çağırdığınızı doğrulayan ve bir sinyal bağlamında çağrılan her güvenli olmayan işlev için bir uyarı mesajı yazdıran bir araç yazdım . Bir sinyal bağlamından eşzamansız olmayan işlevleri çağırma sorununu çözmese de, en azından yanlışlıkla yaptığınız durumları bulmanıza yardımcı olur.
Kaynak kodu GitHub üzerindedir . Aşırı signal/sigactionyükleyerek çalışır , ardından PLTgüvenli olmayan işlevlerin girişlerini geçici olarak ele geçirir ; bu, güvenli olmayan işlevlere yapılan çağrıların bir sarmalayıcıya yeniden yönlendirilmesine neden olur.
Bir seçme döngüsüne sahip programlarda özellikle yararlı olan bir teknik , bir sinyal alındığında bir borunun altına tek bir bayt yazmak ve ardından sinyali seçme döngüsünde işlemektir. Bu satırlar boyunca bir şeyler (hata işleme ve diğer ayrıntılar kısa olması için atlanmıştır) :
static int sigPipe[2];
static void gotSig ( int num ) { write(sigPipe[1], "!", 1); }
int main ( void ) {
pipe(sigPipe);
/* use sigaction to point signal(s) at gotSig() */
FD_SET(sigPipe[0], &readFDs);
for (;;) {
n = select(nFDs, &readFDs, ...);
if (FD_ISSET(sigPipe[0], &readFDs)) {
read(sigPipe[0], ch, 1);
/* do something about the signal here */
}
/* ... the rest of your select loop */
}
}
Hangi sinyal olduğunu önemsiyorsanız , borudaki bayt sinyal numarası olabilir.
Kendi eşzamansız sinyal güvenliğinizi uygulayın snprintf("%dve kullanınwrite
Düşündüğüm kadar kötü değil , C'deki bir int dizgeye nasıl dönüştürülür? birkaç uygulamaya sahiptir.
Sinyal işleyicilerin erişebileceği yalnızca iki ilginç veri türü olduğundan:
sig_atomic_t küresellerint sinyal argümanıbu temelde tüm ilginç kullanım durumlarını kapsar.
Aynı strcpyzamanda sinyal güvenliğinin olması, işleri daha da iyi hale getirir.
Aşağıdaki POSIX programı, ile tetikleyebileceğiniz SIGINT şimdiye kadar kaç kez aldığını Ctrl + Cve ve sinyal kimliğini standart olarak yazdırır .
Ctrl + \(SIGQUIT) ile programdan çıkabilirsiniz .
main.c:
#define _XOPEN_SOURCE 700
#include <assert.h>
#include <limits.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
/* Calculate the minimal buffer size for a given type.
*
* Here we overestimate and reserve 8 chars per byte.
*
* With this size we could even print a binary string.
*
* - +1 for NULL terminator
* - +1 for '-' sign
*
* A tight limit for base 10 can be found at:
* /programming/8257714/how-to-convert-an-int-to-string-in-c/32871108#32871108
*
* TODO: get tight limits for all bases, possibly by looking into
* glibc's atoi: /programming/190229/where-is-the-itoa-function-in-linux/52127877#52127877
*/
#define ITOA_SAFE_STRLEN(type) sizeof(type) * CHAR_BIT + 2
/* async-signal-safe implementation of integer to string conversion.
*
* Null terminates the output string.
*
* The input buffer size must be large enough to contain the output,
* the caller must calculate it properly.
*
* @param[out] value Input integer value to convert.
* @param[out] result Buffer to output to.
* @param[in] base Base to convert to.
* @return Pointer to the end of the written string.
*/
char *itoa_safe(intmax_t value, char *result, int base) {
intmax_t tmp_value;
char *ptr, *ptr2, tmp_char;
if (base < 2 || base > 36) {
return NULL;
}
ptr = result;
do {
tmp_value = value;
value /= base;
*ptr++ = "ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[35 + (tmp_value - value * base)];
} while (value);
if (tmp_value < 0)
*ptr++ = '-';
ptr2 = result;
result = ptr;
*ptr-- = '\0';
while (ptr2 < ptr) {
tmp_char = *ptr;
*ptr--= *ptr2;
*ptr2++ = tmp_char;
}
return result;
}
volatile sig_atomic_t global = 0;
void signal_handler(int sig) {
char key_str[] = "count, sigid: ";
/* This is exact:
* - the null after the first int will contain the space
* - the null after the second int will contain the newline
*/
char buf[2 * ITOA_SAFE_STRLEN(sig_atomic_t) + sizeof(key_str)];
enum { base = 10 };
char *end;
end = buf;
strcpy(end, key_str);
end += sizeof(key_str);
end = itoa_safe(global, end, base);
*end++ = ' ';
end = itoa_safe(sig, end, base);
*end++ = '\n';
write(STDOUT_FILENO, buf, end - buf);
global += 1;
signal(sig, signal_handler);
}
int main(int argc, char **argv) {
/* Unit test itoa_safe. */
{
typedef struct {
intmax_t n;
int base;
char out[1024];
} InOut;
char result[1024];
size_t i;
InOut io;
InOut ios[] = {
/* Base 10. */
{0, 10, "0"},
{1, 10, "1"},
{9, 10, "9"},
{10, 10, "10"},
{100, 10, "100"},
{-1, 10, "-1"},
{-9, 10, "-9"},
{-10, 10, "-10"},
{-100, 10, "-100"},
/* Base 2. */
{0, 2, "0"},
{1, 2, "1"},
{10, 2, "1010"},
{100, 2, "1100100"},
{-1, 2, "-1"},
{-100, 2, "-1100100"},
/* Base 35. */
{0, 35, "0"},
{1, 35, "1"},
{34, 35, "Y"},
{35, 35, "10"},
{100, 35, "2U"},
{-1, 35, "-1"},
{-34, 35, "-Y"},
{-35, 35, "-10"},
{-100, 35, "-2U"},
};
for (i = 0; i < sizeof(ios)/sizeof(ios[0]); ++i) {
io = ios[i];
itoa_safe(io.n, result, io.base);
if (strcmp(result, io.out)) {
printf("%ju %d %s\n", io.n, io.base, io.out);
assert(0);
}
}
}
/* Handle the signals. */
if (argc > 1 && !strcmp(argv[1], "1")) {
signal(SIGINT, signal_handler);
while(1);
}
return EXIT_SUCCESS;
}
Derleyin ve çalıştırın:
gcc -std=c99 -Wall -Wextra -o main main.c
./main 1
Ctrl + C'ye on beş kez bastıktan sonra terminal şunu gösterir:
^Ccount, sigid: 0 2
^Ccount, sigid: 1 2
^Ccount, sigid: 2 2
^Ccount, sigid: 3 2
^Ccount, sigid: 4 2
^Ccount, sigid: 5 2
^Ccount, sigid: 6 2
^Ccount, sigid: 7 2
^Ccount, sigid: 8 2
^Ccount, sigid: 9 2
^Ccount, sigid: 10 2
^Ccount, sigid: 11 2
^Ccount, sigid: 12 2
^Ccount, sigid: 13 2
^Ccount, sigid: 14 2
2sinyal numarası nerede SIGINT.
Ubuntu 18.04'te test edilmiştir. GitHub yukarı akış .
write()Asenkron sinyal güvenli bir işlev olan doğrudan da kullanabilirsiniz .
#include <unistd.h>
int main(void) {
write(1,"Hello World!", 12);
return 0;
}
Pthread kitaplığını kullanıyorsanız, sinyal işleyicilerinde printf'i kullanabilirsiniz. unix / posix, printf'in iş parçacıkları için atomik olduğunu belirtir, çünkü Dave Butenhof buradan yanıt verin: https://groups.google.com/forum/#!topic/comp.programming.threads/1-bU71nYgqw Daha net bir resim elde etmek için unutmayın Printf çıktısı için, uygulamanızı GUI tarafından oluşturulan sözde-tty yerine bir konsolda çalıştırmalısınız (linux'ta konsol 1'i başlatmak için ctl + alt + f1 kullanın).
printfŞu sinyal yönlendiricideki aramayı görüyor musunuz? Silin.