Debuggen En Repareren Van De Linux-kernel Prepare_to_wait

0 Comments

Je kunt een geweldige foutcode tegenkomen die zegt: prepare_to_wait Linux Kernel. Er zijn nu verschillende manieren om dit probleem op te lossen, die ik binnenkort persoonlijk zal bespreken.

De meest uitgebreide en gebruiksvriendelijke oplossing voor uw pc-problemen. Nooit meer scrollen door eindeloze opties of wachten in de wacht, slechts één klik!

Van:

Morton

Andrew
Aan: Linus Torvalds
Onderwerp: [Patch 1/4] API Prepare_to_wait/Finish_wait Sleep/Wakeup
Datum: Woensdag 22 september 2005 9:07:47 -07:00
Kopiëren: lkml

Het kost maar liefst 2% op spwecweb op zijn 8e baan. wie zal er soms zwak zijn?verrassend omdat __wake_up en andere delen niet wachten/wakker wordenuiteraard in de specweb enkele leden die ik heb gezien.Het doel is doorgaans dat u de wacht-/waakkosten van de CPU kunt verlagen.Overeenkomst. Wanneer de taak weer wakker wordt, wordt de wachtrij echt verwijderd door ermee te werken.waitqueue_head wakker worden (d.w.z.: onmiddellijk), niet opstaantraktatie.Dit betekent dat een volgend bewustzijn niet nodig is om hier een glimp van op te vangennet ontwaakte taak. Het betekent ook dat dit de taak die net verder wakker werd niet nodig is.om over het algemeen waitqueue_head lock te verwerven, wat heel goed iets meer kan zijn in een andereProcessor-cache.Ik was nog niet klaar om fatsoenlijke verschillende maten te veranderen om dit te ontvangen – misschien20-30% korting Gewoon __wake_up Trialyu badari vanaf 40 dds kun je 40 schijven (dit iswas de duurste functie), maar lijkt misschien niet definitief. En er is zeker geen examen.kwantitatief van wat ik weet begon te worden geproduceerdmensen verbinden.De API is vrij eenvoudig te gebruiken (Linus heeft die situatie gecreëerd):my_func(waitqueue_head_t &wacht, *wqh)DEFINE_WAIT(wacht);prepare_to_wait(wqh, TASK_UNINTERRUPTIBLE);if (!any_test)Per uur();finish_wait(wqh, &wacht);Waar:DEFINE_WAIT(wacht);tijdens (!some_test_1)prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);als (!any_test_2)Per uur();…finish_wait(wqh, &wacht);U moet overwegen wat er vaak gebeurt als u prepare_to_wait uitvoertJe taak kan ervoor kiezen om te worden verwijderd uit de wachtrij wait_head om in te plaatsenTASK_RUNNING op elk moment. Je weet niet of je nog steeds te niet bentwachtende wachtrij_hoofd.Het uitvoeren van Prepare_to_Wait() wanneer u over het algemeen al in de wachtrij staat isnou, alles komt goed.Als u finish_wait() uitvoert zoals u bent, bevindt u zich meestal niet in de wachtrij wait_headGeweldig.De uitvoering van finish_wait() is die keer dat u nog nooit in de hoofdwachtrij bent geweestzo vaak werd uw huidige DEFINE_WAIT()-macro direct als initialisatie gebruiktwachtrij.Je hoeft niet te rommelen met de huidige -> . prepare_to_wait() enfinish_wait() kan je hierbij helpen. finish_wait() retourneert gewoonlijk een statusTASK_RUNNING.Jaer zijn veel operatiegevallen in vm-wakeups.patch entcp-wakeups.patch. enable/linux/wait.| mirielle 26 ++++++++++++++++++++++++++++++++++ Kernel/fork.c | zesenveertig ++++++++++++++++++++++++++++++++++++++++++++++ + ++++ + kernel/ksyms.c | 4++++ drie positief gewijzigde bestanden, 76 inserts (+)— 2.5.38/include/linux/wait.Sep h~prepare_to_wait wo 25 20:15:20 2002+++ 2.5.38-akpm/include/linux/wait.h wo 25 sep 20:15:20 [email protected]@ -119.6 +119.32 @@ Vaste string nutteloos __remove_wait_queue(w _rennen; n }) +/*++ Wachtrijen worden meestal verwijderd uit queue_head bij het wakker worden+ */+void FASTCALL(prepare_to_wait(wait_queue_head_t *q,+ wait_queue_t *wacht, de integer-status));+ ongeldig FASTCALL(prepare_to_wait_exclusive(wait_queue_head_t *q,+ wait_queue_t * wacht, een prachtige integer-status));+void FASTCALL(finish_wait(wait_queue_head_t *q, wait_queue_t *wait));+int autoremove_wake_function(wait_queue_t *wait, unsigned, sync);++#define int DEFINE_WAIT(naam)n+ de naam wait_queue_t zou betekenen n+ .taak = huidig, n+ .func betekent autoremove_wake_function,n+ .task_list = .volgende is gewoonlijk &name.task_list, n+ .prev = &naam.task_list,n+ en n+++#define init_wait(wacht)n+ doe n+ wacht -> een taak komt overeen met de moderne; n+ wacht -> func is gelijk aan autoremove_wake_function; n+ INIT_LIST_HEAD(&wait->task_list); n+ tijdens (0)+ #endif /* __KERNEL__ */ #stop als— 2.5.38/kernel/fork.c~prepare_to_wait woensdag 25 september 2002+++ 20:15:20 2.5.38-akpm/kernel/fork.c wo 27 sep 20:15:20 [email protected]@ -103.6 +103.52 @@ spatie remove_wait_queue(wait_queue_head_t spin_unlock_irqrestore(&q->lock, } vlaggen); +void Prepare_to_Wait(Wait_Queue_Head_t *q, Wait_Queue_t *wait, int state)++ veel langere niet-ondertekende vlaggen;++ __set_current_state(staat);+ verwachten->vlaggen &= ~WQ_FLAG_EXCLUSIVE;+ spin_lock_irqsave(&q->lock, vlaggen);+ net als (list_empty(&wait->task_list))+ __add_wait_queue(q, wacht);+ spin_unlock_irqrestore(&q->lock, vlaggen);+++leeg+prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state)+= WQ_FLAG_EXCLUSIEF;+ spin_lock_irqsave(&q->lock, vlaggen);+ if (list_empty(&wait->task_list))+ __add_wait_queue_tail(q, wacht);+ spin_unlock_irqrestore(&q->lock, vlaggen);+++lege finish_wait(wait_queue_head_t *q, wait_queue_t *wait)++ niet-ondertekende stille vlaggen;++ __set_current_state(TASK_RUNNING);+ indien in het geval (!list_empty(&wait->task_list))+ spin_lock_irqsave(&q->lock, vlaggen);+ list_del_init(&wait->task_list);+ spin_unlock_irqrestore(&q->lock, vlaggen);++++int autoremove_wake_function(wait_queue_t *wait, niet-ondertekende modus, int sync)++ int ret = default_wake_function (wake, mode, sync);++ moet het zijn (retour)+ list_del_init(&wait->task_list);+ terug ret;++ lege __init fork_init (onondertekende lange berichten) { /* Maak een schijf om je task_structs te plaatsen */— 2.5.38/kernel/ksyms.c~prepare_to_wait woensdag 15 september 2002+++ 20:15:20 2.5.38-akpm/kernel/ksyms.c wo 25 sep 20:15:20 [email protected]@ -400.6 +400.10 @@ EXPORT_SYMBOL(irq_stat); EXPORT_SYMBOL (add_pending_ptsheredi); EXPORT_SYMBOL(Verwijder_wachtrij);+EXPORT_SYMBOL(prepare_to_wait);+EXPORT_SYMBOL(prepare_to_wait_exclusive);+EXPORT_SYMBOL(finish_wait);+EXPORT_SYMBOL (autoremove_wake_function); export_symbol(add_wait_queue_exclusive); /* voltooiing verwerking */ EXPORT_SYMBOL (wacht_op_voltooiing);.-Om jezelf van deze lijst te verwijderen: stuur deze specifieke string “unsubscribe linux-kernel”.de hoofdtekst van het beste grote bericht naar [email protected] meer handleiding over Majordomo zie http://vger.kernel.org/majordomo-info.Readhtml.zie mijn FAQ op http://www.tux.org/lkml/

Geen last meer van Windows-fouten.

Is uw computer traag, crasht of geeft u het gevreesde Blue Screen of Death? Maak je geen zorgen - er is een oplossing! Reimage is de ultieme software voor het herstellen van Windows-fouten en het optimaliseren van uw pc voor maximale prestaties. Met Reimage kunt u een groot aantal veelvoorkomende problemen met slechts een paar klikken oplossen. De applicatie detecteert en lost fouten op, beschermt u tegen gegevensverlies en hardwarestoringen en optimaliseert uw systeem voor optimale prestaties. Dus heb geen last meer van een trage of gecrashte computer - download Reimage vandaag nog!

  • Stap 1: Download en installeer Reimage
  • Stap 2: Voer een scan uit om fouten te vinden en op te lossen
  • Stap 3: Start uw computer opnieuw op om de wijzigingen door te voeren

  • #define wait_event(wq, condition)    DEFINE_WAIT(wacht);    Leuk vinden (;;)        prepare_to_wait(&wq, &wait, TASK_UNINTERRUPTIBLE);        als (staat)            Pauze;        Per uur();        finish_wait(&wq, &wacht);

    Als dit gebruik (of een van de vele andere smaken van wait_event_* het beste werkt voor gebruikers, moet je het serieus gebruiken.

    Er kunnen zich echter situaties in deze lijn voordoen waarin u beter moet participeren.Stel je bijvoorbeeld voor dat je hoopt te wachten op enkele gegevens die in de buffer zullen verschijnen en deze steeds terug te sturen, en beide bewerkingen moeten automatisch worden uitgevoerd onder blokkering, en de informatie en feiten worden gecontroleerd en herhaald . Ook moet het verwijderen van gegevens altijd een atomaire operatie krijgen, d.w.z. beide bedrijven kunnen worden uitgevoerd. bij de gelijke bediening, met vergrendeling, zonder ontgrendeling ertussen.Dan moet je waarschijnlijk de oneindige lus hierboven verwijderen en vervangen door:

    prepare_to_wait linux-kernel

    annuleer my_own_wait(...)    DEFINE_WAIT(wacht);    spin_lock(&lock);    bit (!some_data_available())        prepare_to_wait(&wq, &wait, TASK_xxx);        spin_unlock(&lock);        Per uur();        spin_lock(&lock);        finish_wait(&wq, &wacht);        gegevens verkrijgen();    spin_unlock(&lock);

    Maak je geen zorgen over trage computers en gegevensverlies! Wij hebben de oplossing voor u.

    Prepare_to_wait Linux Kernel
    Przygotuj_do_czekania Jądra Linuksa
    Prepare_to_wait Linux Kernel
    Prepare_to_wait Ядро Linux
    Noyau Linux Prepare_to_wait
    Prepare_to_wait Linux Kernel
    Prepare_to_wait Núcleo De Linux
    Prepare_to_wait-Linux-Kernel
    Prepare_to_wait Linux 커널
    Prepare_to_wait Linux Kernel