With more cores becoming available in each future generation of microprocessors (i.e. the well-known Moore's Law), scalability is becoming an increasingly important issue. Scalability of the operating system, in particular, is critical to such systems. To study OS scalability and many other issues related to OS performance on multicore systems, software and hardware profilers are indispensable tools. Hardware profilers give detailed performance information on hardware components with minimal overhead, but are difficult to relate the collected information to specific software events. Hence, most of the OS profiling tools are software based. Such profilers often incur significant overheads if more precise measurements are required. The situation is exacerbated further because most of these tools have scalability issue themselves in that their overheads could grow more than proportionately to the number of cores and/or the number of threads in a system. Our results showed that such overheads not only cause much longer execution time (often by orders of magnitude), but also perturb program execution and produce misleading profiling results. In order to mitigate such problems, we propose an approach, called selective profiling, that uses a mix of profiling tools with different levels of precision and overheads to produce the desired results with tolerable overhead. In selective-profiling, potential scalability bottlenecks and hotspots are first identified by low-overhead tracers. More detailed information of the selected bottlenecks and hotspots are then collected by a sampler with more precision but heavier overheads. Since the sampler only focuses on the selected bottlenecks and hotspots instead of the entire program, the overhead can be substantially reduced. Using such an approach on some OS benchmarks, we show that the proposed selectiveprofiling approach can efficiently identify their scalability bottlenecks with much reduced overheads.