Whamcloud - gitweb
LU-459 tests: quiet spurious console/test messages
[fs/lustre-release.git] / libcfs / libcfs / winnt / winnt-prim.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 only,
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License version 2 for more details (a copy is included
16  * in the LICENSE file that accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License
19  * version 2 along with this program; If not, see
20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
21  *
22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23  * CA 95054 USA or visit www.sun.com if you need additional information or
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
30  * Use is subject to license terms.
31  *
32  * Copyright (c) 2011, Whamcloud, Inc.
33  */
34 /*
35  * This file is part of Lustre, http://www.lustre.org/
36  * Lustre is a trademark of Sun Microsystems, Inc.
37  */
38
39 #define DEBUG_SUBSYSTEM S_LNET
40
41 #include <libcfs/libcfs.h>
42
43
44 /*
45  *  Thread routines
46  */
47
48 /*
49  * cfs_thread_proc
50  *   Lustre thread procedure wrapper routine (It's an internal routine)
51  *
52  * Arguments:
53  *   context:  a structure of cfs_thread_context_t, containing
54  *             all the necessary parameters
55  *
56  * Return Value:
57  *   void: N/A
58  *
59  * Notes:
60  *   N/A
61  */
62
63 void
64 cfs_thread_proc(
65     void * context
66     )
67 {
68     cfs_thread_context_t * thread_context =
69         (cfs_thread_context_t *) context;
70
71     /* Execute the specified function ... */
72
73     if (thread_context->func) {
74         (thread_context->func)(thread_context->arg);
75     }
76
77     /* Free the context memory */
78
79     cfs_free(context);
80
81     /* Terminate this system thread */
82
83     PsTerminateSystemThread(STATUS_SUCCESS);
84 }
85
86 /*
87  * cfs_create_thread
88  *   Create a system thread to execute the routine specified
89  *
90  * Arguments:
91  *   func:  function to be executed in the thread
92  *   arg:   argument transferred to func function
93  *   flag:  thread creation flags.
94  *
95  * Return Value:
96  *   int:   0 on success or error codes
97  *
98  * Notes:
99  *   N/A
100  */
101
102 int cfs_create_thread(int (*func)(void *), void *arg, unsigned long flag)
103 {
104     cfs_handle_t  thread = NULL;
105     NTSTATUS      status;
106     cfs_thread_context_t * context = NULL;
107
108     /* Allocate the context to be transferred to system thread */
109
110     context = cfs_alloc(sizeof(cfs_thread_context_t), CFS_ALLOC_ZERO);
111
112     if (!context) {
113         return -ENOMEM;
114     }
115
116     context->func  = func;
117     context->arg   = arg;
118
119     /* Create system thread with the cfs_thread_proc wrapper */
120
121     status = PsCreateSystemThread(
122                 &thread,
123                 (ACCESS_MASK)0L,
124                 0, 0, 0,
125                 cfs_thread_proc,
126                 context);
127
128     if (!NT_SUCCESS(status)) {
129
130
131         cfs_free(context);
132
133         /* We need translate the nt status to linux error code */
134
135         return cfs_error_code(status);
136     }
137
138     //
139     //  Query the thread id of the newly created thread
140     //
141
142     ZwClose(thread);
143
144     return 0;
145 }
146
147
148 /*
149  * Symbols routines
150  */
151
152
153 static CFS_DECLARE_RWSEM(cfs_symbol_lock);
154 CFS_LIST_HEAD(cfs_symbol_list);
155
156 int libcfs_is_mp_system = FALSE;
157
158 /*
159  * cfs_symbol_get
160  *   To query the specified symbol form the symbol table
161  *
162  * Arguments:
163  *   name:  the symbol name to be queried
164  *
165  * Return Value:
166  *   If the symbol is in the table, return the address of it.
167  *   If not, return NULL.
168  *
169  * Notes:
170  *   N/A
171  */
172
173 void *
174 cfs_symbol_get(const char *name)
175 {
176     cfs_list_t              *walker;
177     struct cfs_symbol       *sym = NULL;
178
179     cfs_down_read(&cfs_symbol_lock);
180     cfs_list_for_each(walker, &cfs_symbol_list) {
181         sym = cfs_list_entry (walker, struct cfs_symbol, sym_list);
182         if (!strcmp(sym->name, name)) {
183             sym->ref ++;
184             break;
185         }
186     }
187     cfs_up_read(&cfs_symbol_lock);
188
189     if (sym != NULL)
190         return sym->value;
191
192     return NULL;
193 }
194
195 /*
196  * cfs_symbol_put
197  *   To decrease the reference of  the specified symbol
198  *
199  * Arguments:
200  *   name:  the symbol name to be dereferred
201  *
202  * Return Value:
203  *   N/A
204  *
205  * Notes:
206  *   N/A
207  */
208
209 void
210 cfs_symbol_put(const char *name)
211 {
212     cfs_list_t              *walker;
213     struct cfs_symbol       *sym = NULL;
214
215     cfs_down_read(&cfs_symbol_lock);
216     cfs_list_for_each(walker, &cfs_symbol_list) {
217         sym = cfs_list_entry (walker, struct cfs_symbol, sym_list);
218         if (!strcmp(sym->name, name)) {
219             LASSERT(sym->ref > 0);
220             sym->ref--;
221             break;
222         }
223     }
224     cfs_up_read(&cfs_symbol_lock);
225
226     LASSERT(sym != NULL);
227 }
228
229
230 /*
231  * cfs_symbol_register
232  *   To register the specified symbol infromation
233  *
234  * Arguments:
235  *   name:  the symbol name to be dereferred
236  *   value: the value that the symbol stands for
237  *
238  * Return Value:
239  *   N/A
240  *
241  * Notes:
242  *   Zero: Succeed to register
243  *   Non-Zero: Fail to register the symbol
244  */
245
246 int
247 cfs_symbol_register(const char *name, const void *value)
248 {
249     cfs_list_t              *walker;
250     struct cfs_symbol       *sym = NULL;
251     struct cfs_symbol       *new = NULL;
252
253     new = cfs_alloc(sizeof(struct cfs_symbol), CFS_ALLOC_ZERO);
254     if (!new) {
255         return (-ENOMEM);
256     }
257     strncpy(new->name, name, CFS_SYMBOL_LEN);
258     new->value = (void *)value;
259     new->ref = 0;
260     CFS_INIT_LIST_HEAD(&new->sym_list);
261
262     cfs_down_write(&cfs_symbol_lock);
263     cfs_list_for_each(walker, &cfs_symbol_list) {
264         sym = cfs_list_entry (walker, struct cfs_symbol, sym_list);
265         if (!strcmp(sym->name, name)) {
266             cfs_up_write(&cfs_symbol_lock);
267             cfs_free(new);
268             return 0; // alreay registerred
269         }
270     }
271     cfs_list_add_tail(&new->sym_list, &cfs_symbol_list);
272     cfs_up_write(&cfs_symbol_lock);
273
274     return 0;
275 }
276
277 /*
278  * cfs_symbol_unregister
279  *   To unregister/remove the specified symbol
280  *
281  * Arguments:
282  *   name:  the symbol name to be dereferred
283  *
284  * Return Value:
285  *   N/A
286  *
287  * Notes:
288  *   N/A
289  */
290
291 void
292 cfs_symbol_unregister(const char *name)
293 {
294     cfs_list_t              *walker;
295     cfs_list_t              *nxt;
296     struct cfs_symbol       *sym = NULL;
297
298     cfs_down_write(&cfs_symbol_lock);
299     cfs_list_for_each_safe(walker, nxt, &cfs_symbol_list) {
300         sym = cfs_list_entry (walker, struct cfs_symbol, sym_list);
301         if (!strcmp(sym->name, name)) {
302             LASSERT(sym->ref == 0);
303             cfs_list_del (&sym->sym_list);
304             cfs_free(sym);
305             break;
306         }
307     }
308     cfs_up_write(&cfs_symbol_lock);
309 }
310
311 /*
312  * cfs_symbol_clean
313  *   To clean all the symbols
314  *
315  * Arguments:
316  *   N/A
317  *
318  * Return Value:
319  *   N/A
320  *
321  * Notes:
322  *   N/A
323  */
324
325 void
326 cfs_symbol_clean()
327 {
328     cfs_list_t          *walker;
329     struct cfs_symbol   *sym = NULL;
330
331     cfs_down_write(&cfs_symbol_lock);
332     cfs_list_for_each(walker, &cfs_symbol_list) {
333         sym = cfs_list_entry (walker, struct cfs_symbol, sym_list);
334         LASSERT(sym->ref == 0);
335         cfs_list_del (&sym->sym_list);
336         cfs_free(sym);
337     }
338     cfs_up_write(&cfs_symbol_lock);
339     return;
340 }
341
342
343
344 /*
345  * Timer routines
346  */
347
348
349 /* Timer dpc procedure */
350
351 static void
352 cfs_timer_dpc_proc (
353     IN PKDPC Dpc,
354     IN PVOID DeferredContext,
355     IN PVOID SystemArgument1,
356     IN PVOID SystemArgument2)
357 {
358     cfs_timer_t *   timer;
359     KIRQL           Irql;
360
361     timer = (cfs_timer_t *) DeferredContext;
362
363     /* clear the flag */
364     KeAcquireSpinLock(&(timer->Lock), &Irql);
365     cfs_clear_flag(timer->Flags, CFS_TIMER_FLAG_TIMERED);
366     KeReleaseSpinLock(&(timer->Lock), Irql);
367
368     /* call the user specified timer procedure */
369     timer->proc((long_ptr_t)timer->arg);
370 }
371
372 void cfs_init_timer(cfs_timer_t *timer)
373 {
374     memset(timer, 0, sizeof(cfs_timer_t));
375 }
376
377 /*
378  * cfs_timer_init
379  *   To initialize the cfs_timer_t
380  *
381  * Arguments:
382  *   timer:  the cfs_timer to be initialized
383  *   func:   the timer callback procedure
384  *   arg:    argument for the callback proc
385  *
386  * Return Value:
387  *   N/A
388  *
389  * Notes:
390  *   N/A
391  */
392
393 void cfs_timer_init(cfs_timer_t *timer, void (*func)(ulong_ptr_t), void *arg)
394 {
395     memset(timer, 0, sizeof(cfs_timer_t));
396
397     timer->proc = func;
398     timer->arg  = arg;
399
400     KeInitializeSpinLock(&(timer->Lock));
401     KeInitializeTimer(&timer->Timer);
402     KeInitializeDpc (&timer->Dpc, cfs_timer_dpc_proc, timer);
403
404     cfs_set_flag(timer->Flags, CFS_TIMER_FLAG_INITED);
405 }
406
407 /*
408  * cfs_timer_done
409  *   To finialize the cfs_timer_t (unused)
410  *
411  * Arguments:
412  *   timer:  the cfs_timer to be cleaned up
413  *
414  * Return Value:
415  *   N/A
416  *
417  * Notes:
418  *   N/A
419  */
420
421 void cfs_timer_done(cfs_timer_t *timer)
422 {
423     return;
424 }
425
426 /*
427  * cfs_timer_arm
428  *   To schedule the timer while touching @deadline
429  *
430  * Arguments:
431  *   timer:  the cfs_timer to be freed
432  *   dealine: timeout value to wake up the timer
433  *
434  * Return Value:
435  *   N/A
436  *
437  * Notes:
438  *   N/A
439  */
440
441 void cfs_timer_arm(cfs_timer_t *timer, cfs_time_t deadline)
442 {
443     LARGE_INTEGER   timeout;
444     KIRQL           Irql;
445
446     KeAcquireSpinLock(&(timer->Lock), &Irql);
447     if (!cfs_is_flag_set(timer->Flags, CFS_TIMER_FLAG_TIMERED)){
448
449         timeout.QuadPart = (LONGLONG)-1*1000*1000*10/CFS_HZ*deadline;
450
451         if (KeSetTimer(&timer->Timer, timeout, &timer->Dpc)) {
452             cfs_set_flag(timer->Flags, CFS_TIMER_FLAG_TIMERED);
453         }
454
455         timer->deadline = deadline;
456     }
457
458     KeReleaseSpinLock(&(timer->Lock), Irql);
459 }
460
461 /*
462  * cfs_timer_disarm
463  *   To discard the timer to be scheduled
464  *
465  * Arguments:
466  *   timer:  the cfs_timer to be discarded
467  *
468  * Return Value:
469  *   N/A
470  *
471  * Notes:
472  *   N/A
473  */
474
475 void cfs_timer_disarm(cfs_timer_t *timer)
476 {
477     KIRQL   Irql;
478
479     KeAcquireSpinLock(&(timer->Lock), &Irql);
480     KeCancelTimer(&(timer->Timer));
481     cfs_clear_flag(timer->Flags, CFS_TIMER_FLAG_TIMERED);
482     KeReleaseSpinLock(&(timer->Lock), Irql);
483 }
484
485
486 /*
487  * cfs_timer_is_armed
488  *   To check the timer is scheduled or not
489  *
490  * Arguments:
491  *   timer:  the cfs_timer to be checked
492  *
493  * Return Value:
494  *   1:  if it's armed.
495  *   0:  if it's not.
496  *
497  * Notes:
498  *   N/A
499  */
500
501 int cfs_timer_is_armed(cfs_timer_t *timer)
502 {
503     int     rc = 0;
504     KIRQL   Irql;
505
506     KeAcquireSpinLock(&(timer->Lock), &Irql);
507     if (cfs_is_flag_set(timer->Flags, CFS_TIMER_FLAG_TIMERED)) {
508         rc = 1;
509     }
510     KeReleaseSpinLock(&(timer->Lock), Irql);
511
512     return rc;
513 }
514
515 /*
516  * cfs_timer_deadline
517  *   To query the deadline of the timer
518  *
519  * Arguments:
520  *   timer:  the cfs_timer to be queried
521  *
522  * Return Value:
523  *   the deadline value
524  *
525  * Notes:
526  *   N/A
527  */
528
529 cfs_time_t cfs_timer_deadline(cfs_timer_t * timer)
530 {
531     return timer->deadline;
532 }
533
534 /*
535  * daemonize routine stub
536  */
537
538 void cfs_daemonize(char *str)
539 {
540     return;
541 }
542
543 int cfs_daemonize_ctxt(char *str) {
544     cfs_daemonize(str);
545     return 0;
546 }
547
548 /*
549  *  routine related with sigals
550  */
551
552 cfs_sigset_t cfs_block_allsigs()
553 {
554         return 0;
555 }
556
557 cfs_sigset_t cfs_block_sigs(sigset_t bit)
558 {
559         return 0;
560 }
561
562 /* Block all signals except for the @sigs. It's only used in
563  * Linux kernel, just a dummy here. */
564 cfs_sigset_t cfs_block_sigsinv(unsigned long sigs)
565 {
566         return 0;
567 }
568
569 void cfs_restore_sigs(cfs_sigset_t old)
570 {
571 }
572
573 int cfs_signal_pending(void)
574 {
575     return 0;
576 }
577
578 void cfs_clear_sigpending(void)
579 {
580     return;
581 }
582
583 /*
584  *  thread cpu affinity routines
585  */
586
587 typedef struct _THREAD_BASIC_INFORMATION {
588     NTSTATUS ExitStatus;
589     PVOID TebBaseAddress;
590     CLIENT_ID ClientId;
591     ULONG_PTR AffinityMask;
592     KPRIORITY Priority;
593     LONG BasePriority;
594 } THREAD_BASIC_INFORMATION;
595
596 typedef THREAD_BASIC_INFORMATION *PTHREAD_BASIC_INFORMATION;
597
598 #define THREAD_QUERY_INFORMATION       (0x0040)
599
600 NTSYSAPI
601 NTSTATUS
602 NTAPI
603 ZwOpenThread (
604     __out PHANDLE ThreadHandle,
605     __in ACCESS_MASK DesiredAccess,
606     __in POBJECT_ATTRIBUTES ObjectAttributes,
607     __in_opt PCLIENT_ID ClientId
608     );
609
610 NTSYSAPI
611 NTSTATUS
612 NTAPI
613 ZwQueryInformationThread (
614     __in HANDLE ThreadHandle,
615     __in THREADINFOCLASS ThreadInformationClass,
616     __out_bcount(ThreadInformationLength) PVOID ThreadInformation,
617     __in ULONG ThreadInformationLength,
618     __out_opt PULONG ReturnLength
619     );
620
621 NTSYSAPI
622 NTSTATUS
623 NTAPI
624 ZwSetInformationThread (
625     __in HANDLE ThreadHandle,
626     __in THREADINFOCLASS ThreadInformationClass,
627     __in_bcount(ThreadInformationLength) PVOID ThreadInformation,
628     __in ULONG ThreadInformationLength
629     );
630
631 HANDLE
632 cfs_open_current_thread()
633 {
634     NTSTATUS         status;
635     HANDLE           handle = NULL;
636     OBJECT_ATTRIBUTES oa;
637     CLIENT_ID        cid;
638
639     /* initialize object attributes */
640     InitializeObjectAttributes( &oa, NULL, OBJ_KERNEL_HANDLE |
641                                 OBJ_CASE_INSENSITIVE, NULL, NULL);
642
643     /* initialize client id */
644     cid.UniqueProcess = PsGetCurrentProcessId();
645     cid.UniqueThread  = PsGetCurrentThreadId();
646
647     /* get thread handle */
648     status = ZwOpenThread( &handle, THREAD_QUERY_INFORMATION |
649                            THREAD_SET_INFORMATION, &oa, &cid);
650     if (!NT_SUCCESS(status)) {
651         handle = NULL;
652     }
653
654     return handle;
655 }
656
657 void
658 cfs_close_thread_handle(HANDLE handle)
659 {
660     if (handle)
661         ZwClose(handle);
662 }
663
664 KAFFINITY
665 cfs_query_thread_affinity()
666 {
667     NTSTATUS         status;
668     HANDLE           handle = NULL;
669     DWORD            size;
670     THREAD_BASIC_INFORMATION TBI = {0};
671
672     /* open current thread */
673     handle = cfs_open_current_thread();
674     if (!handle) {
675         goto errorout;
676     }
677
678     /* query thread cpu affinity */
679     status = ZwQueryInformationThread(handle, ThreadBasicInformation,
680                        &TBI, sizeof(THREAD_BASIC_INFORMATION), &size);
681     if (!NT_SUCCESS(status)) {
682         goto errorout;
683     }
684
685 errorout:
686
687     cfs_close_thread_handle(handle);
688     return TBI.AffinityMask;
689 }
690
691 int
692 cfs_set_thread_affinity(KAFFINITY affinity)
693 {
694     NTSTATUS         status;
695     HANDLE           handle = NULL;
696
697     /* open current thread */
698     handle = cfs_open_current_thread();
699     if (!handle) {
700         goto errorout;
701     }
702
703     /* set thread cpu affinity */
704     status = ZwSetInformationThread(handle, ThreadAffinityMask,
705                                     &affinity, sizeof(KAFFINITY));
706     if (!NT_SUCCESS(status)) {
707         goto errorout;
708     }
709
710 errorout:
711
712     cfs_close_thread_handle(handle);
713     return NT_SUCCESS(status);
714 }
715
716 int
717 cfs_tie_thread_to_cpu(int cpu)
718 {
719     return cfs_set_thread_affinity((KAFFINITY) (1 << cpu));
720 }
721
722 int
723 cfs_set_thread_priority(KPRIORITY priority)
724 {
725     NTSTATUS         status;
726     HANDLE           handle = NULL;
727
728     /* open current thread */
729     handle = cfs_open_current_thread();
730     if (!handle) {
731         goto errorout;
732     }
733
734     /* set thread cpu affinity */
735     status = ZwSetInformationThread(handle, ThreadPriority,
736                                     &priority, sizeof(KPRIORITY));
737     if (!NT_SUCCESS(status)) {
738         KdPrint(("set_thread_priority failed: %xh\n", status));
739         goto errorout;
740     }
741
742 errorout:
743
744     cfs_close_thread_handle(handle);
745     return NT_SUCCESS(status);
746 }
747
748 int cfs_need_resched(void)
749 {
750         return 0;
751 }
752
753 void cfs_cond_resched(void)
754 {
755 }
756
757 /**
758  **  Initialize routines
759  **/
760
761 void cfs_libc_init();
762
763 int
764 libcfs_arch_init(void)
765 {
766     int         rc;
767
768     cfs_spinlock_t  lock;
769     /* Workground to check the system is MP build or UP build */
770     cfs_spin_lock_init(&lock);
771     cfs_spin_lock(&lock);
772     libcfs_is_mp_system = (int)lock.lock;
773     /* MP build system: it's a real spin, for UP build system, it
774        only raises the IRQL to DISPATCH_LEVEL */
775     cfs_spin_unlock(&lock);
776
777     /* initialize libc routines (confliction between libcnptr.lib
778        and kernel ntoskrnl.lib) */
779     cfs_libc_init();
780
781     /* create slab memory caches for page alloctors */
782     cfs_page_t_slab = cfs_mem_cache_create(
783         "CPGT", sizeof(cfs_page_t), 0, 0 );
784
785     cfs_page_p_slab = cfs_mem_cache_create(
786         "CPGP", CFS_PAGE_SIZE, 0, 0 );
787
788     if ( cfs_page_t_slab == NULL ||
789          cfs_page_p_slab == NULL ){
790         rc = -ENOMEM;
791         goto errorout;
792     }
793
794     rc = init_task_manager();
795     if (rc != 0) {
796         cfs_enter_debugger();
797         KdPrint(("winnt-prim.c:libcfs_arch_init: error initializing task manager ...\n"));
798         goto errorout;
799     }
800
801     /* initialize the proc file system */
802     rc = proc_init_fs();
803     if (rc != 0) {
804         cfs_enter_debugger();
805         KdPrint(("winnt-prim.c:libcfs_arch_init: error initializing proc fs ...\n"));
806         cleanup_task_manager();
807         goto errorout;
808     }
809
810     /* initialize the tdi data */
811     rc = ks_init_tdi_data();
812     if (rc != 0) {
813         cfs_enter_debugger();
814         KdPrint(("winnt-prim.c:libcfs_arch_init: failed to initialize tdi.\n"));
815         proc_destroy_fs();
816         cleanup_task_manager();
817         goto errorout;
818     }
819
820     rc = start_shrinker_timer();
821
822 errorout:
823
824     if (rc != 0) {
825         /* destroy the taskslot cache slab */
826         if (cfs_page_t_slab) {
827             cfs_mem_cache_destroy(cfs_page_t_slab);
828         }
829         if (cfs_page_p_slab) {
830             cfs_mem_cache_destroy(cfs_page_p_slab);
831         }
832     }
833
834     return rc;
835 }
836
837 void
838 libcfs_arch_cleanup(void)
839 {
840     /* stop shrinker timer */
841     stop_shrinker_timer();
842
843     /* finialize the tdi data */
844     ks_fini_tdi_data();
845
846     /* detroy the whole proc fs tree and nodes */
847     proc_destroy_fs();
848
849     /* cleanup context of task manager */
850     cleanup_task_manager();
851
852     /* destroy the taskslot cache slab */
853     if (cfs_page_t_slab) {
854         cfs_mem_cache_destroy(cfs_page_t_slab);
855     }
856
857     if (cfs_page_p_slab) {
858         cfs_mem_cache_destroy(cfs_page_p_slab);
859     }
860
861     return;
862 }
863
864 EXPORT_SYMBOL(libcfs_arch_init);
865 EXPORT_SYMBOL(libcfs_arch_cleanup);