aboutsummaryrefslogtreecommitdiffstats
path: root/include
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2008-11-09 15:20:56 -0500
committerLinus Torvalds <torvalds@linux-foundation.org>2008-11-09 15:20:56 -0500
commitcb56d98e2a7530615899597551db685d68a2e852 (patch)
tree458a2dc64385f35799c55971ea7b3fe1a2ec218f /include
parent6209344f5a3795d34b7f2c0061f49802283b6bdd (diff)
parent984f2f377fdfd098f5ae58d09ee04d5e29e6112b (diff)
Merge branch 'cpus4096' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip
* 'cpus4096' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip: cpumask: introduce new API, without changing anything, v3 cpumask: new API, v2 cpumask: introduce new API, without changing anything
Diffstat (limited to 'include')
-rw-r--r--include/linux/cpumask.h559
-rw-r--r--include/linux/smp.h9
-rw-r--r--include/linux/workqueue.h8
3 files changed, 574 insertions, 2 deletions
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index d3219d73f8e6..21e1dd43e52a 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -5,6 +5,9 @@
5 * Cpumasks provide a bitmap suitable for representing the 5 * Cpumasks provide a bitmap suitable for representing the
6 * set of CPU's in a system, one bit position per CPU number. 6 * set of CPU's in a system, one bit position per CPU number.
7 * 7 *
8 * The new cpumask_ ops take a "struct cpumask *"; the old ones
9 * use cpumask_t.
10 *
8 * See detailed comments in the file linux/bitmap.h describing the 11 * See detailed comments in the file linux/bitmap.h describing the
9 * data type on which these cpumasks are based. 12 * data type on which these cpumasks are based.
10 * 13 *
@@ -31,7 +34,7 @@
31 * will span the entire range of NR_CPUS. 34 * will span the entire range of NR_CPUS.
32 * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
33 * 36 *
34 * The available cpumask operations are: 37 * The obsolescent cpumask operations are:
35 * 38 *
36 * void cpu_set(cpu, mask) turn on bit 'cpu' in mask 39 * void cpu_set(cpu, mask) turn on bit 'cpu' in mask
37 * void cpu_clear(cpu, mask) turn off bit 'cpu' in mask 40 * void cpu_clear(cpu, mask) turn off bit 'cpu' in mask
@@ -138,7 +141,7 @@
138#include <linux/threads.h> 141#include <linux/threads.h>
139#include <linux/bitmap.h> 142#include <linux/bitmap.h>
140 143
141typedef struct { DECLARE_BITMAP(bits, NR_CPUS); } cpumask_t; 144typedef struct cpumask { DECLARE_BITMAP(bits, NR_CPUS); } cpumask_t;
142extern cpumask_t _unused_cpumask_arg_; 145extern cpumask_t _unused_cpumask_arg_;
143 146
144#define cpu_set(cpu, dst) __cpu_set((cpu), &(dst)) 147#define cpu_set(cpu, dst) __cpu_set((cpu), &(dst))
@@ -527,4 +530,556 @@ extern cpumask_t cpu_active_map;
527#define for_each_online_cpu(cpu) for_each_cpu_mask_nr((cpu), cpu_online_map) 530#define for_each_online_cpu(cpu) for_each_cpu_mask_nr((cpu), cpu_online_map)
528#define for_each_present_cpu(cpu) for_each_cpu_mask_nr((cpu), cpu_present_map) 531#define for_each_present_cpu(cpu) for_each_cpu_mask_nr((cpu), cpu_present_map)
529 532
533/* These are the new versions of the cpumask operators: passed by pointer.
534 * The older versions will be implemented in terms of these, then deleted. */
535#define cpumask_bits(maskp) ((maskp)->bits)
536
537#if NR_CPUS <= BITS_PER_LONG
538#define CPU_BITS_ALL \
539{ \
540 [BITS_TO_LONGS(NR_CPUS)-1] = CPU_MASK_LAST_WORD \
541}
542
543/* This produces more efficient code. */
544#define nr_cpumask_bits NR_CPUS
545
546#else /* NR_CPUS > BITS_PER_LONG */
547
548#define CPU_BITS_ALL \
549{ \
550 [0 ... BITS_TO_LONGS(NR_CPUS)-2] = ~0UL, \
551 [BITS_TO_LONGS(NR_CPUS)-1] = CPU_MASK_LAST_WORD \
552}
553
554#define nr_cpumask_bits nr_cpu_ids
555#endif /* NR_CPUS > BITS_PER_LONG */
556
557/* verify cpu argument to cpumask_* operators */
558static inline unsigned int cpumask_check(unsigned int cpu)
559{
560#ifdef CONFIG_DEBUG_PER_CPU_MAPS
561 WARN_ON_ONCE(cpu >= nr_cpumask_bits);
562#endif /* CONFIG_DEBUG_PER_CPU_MAPS */
563 return cpu;
564}
565
566#if NR_CPUS == 1
567/* Uniprocessor. Assume all masks are "1". */
568static inline unsigned int cpumask_first(const struct cpumask *srcp)
569{
570 return 0;
571}
572
573/* Valid inputs for n are -1 and 0. */
574static inline unsigned int cpumask_next(int n, const struct cpumask *srcp)
575{
576 return n+1;
577}
578
579static inline unsigned int cpumask_next_zero(int n, const struct cpumask *srcp)
580{
581 return n+1;
582}
583
584static inline unsigned int cpumask_next_and(int n,
585 const struct cpumask *srcp,
586 const struct cpumask *andp)
587{
588 return n+1;
589}
590
591/* cpu must be a valid cpu, ie 0, so there's no other choice. */
592static inline unsigned int cpumask_any_but(const struct cpumask *mask,
593 unsigned int cpu)
594{
595 return 1;
596}
597
598#define for_each_cpu(cpu, mask) \
599 for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask)
600#define for_each_cpu_and(cpu, mask, and) \
601 for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask, (void)and)
602#else
603/**
604 * cpumask_first - get the first cpu in a cpumask
605 * @srcp: the cpumask pointer
606 *
607 * Returns >= nr_cpu_ids if no cpus set.
608 */
609static inline unsigned int cpumask_first(const struct cpumask *srcp)
610{
611 return find_first_bit(cpumask_bits(srcp), nr_cpumask_bits);
612}
613
614/**
615 * cpumask_next - get the next cpu in a cpumask
616 * @n: the cpu prior to the place to search (ie. return will be > @n)
617 * @srcp: the cpumask pointer
618 *
619 * Returns >= nr_cpu_ids if no further cpus set.
620 */
621static inline unsigned int cpumask_next(int n, const struct cpumask *srcp)
622{
623 /* -1 is a legal arg here. */
624 if (n != -1)
625 cpumask_check(n);
626 return find_next_bit(cpumask_bits(srcp), nr_cpumask_bits, n+1);
627}
628
629/**
630 * cpumask_next_zero - get the next unset cpu in a cpumask
631 * @n: the cpu prior to the place to search (ie. return will be > @n)
632 * @srcp: the cpumask pointer
633 *
634 * Returns >= nr_cpu_ids if no further cpus unset.
635 */
636static inline unsigned int cpumask_next_zero(int n, const struct cpumask *srcp)
637{
638 /* -1 is a legal arg here. */
639 if (n != -1)
640 cpumask_check(n);
641 return find_next_zero_bit(cpumask_bits(srcp), nr_cpumask_bits, n+1);
642}
643
644int cpumask_next_and(int n, const struct cpumask *, const struct cpumask *);
645int cpumask_any_but(const struct cpumask *mask, unsigned int cpu);
646
647/**
648 * for_each_cpu - iterate over every cpu in a mask
649 * @cpu: the (optionally unsigned) integer iterator
650 * @mask: the cpumask pointer
651 *
652 * After the loop, cpu is >= nr_cpu_ids.
653 */
654#define for_each_cpu(cpu, mask) \
655 for ((cpu) = -1; \
656 (cpu) = cpumask_next((cpu), (mask)), \
657 (cpu) < nr_cpu_ids;)
658
659/**
660 * for_each_cpu_and - iterate over every cpu in both masks
661 * @cpu: the (optionally unsigned) integer iterator
662 * @mask: the first cpumask pointer
663 * @and: the second cpumask pointer
664 *
665 * This saves a temporary CPU mask in many places. It is equivalent to:
666 * struct cpumask tmp;
667 * cpumask_and(&tmp, &mask, &and);
668 * for_each_cpu(cpu, &tmp)
669 * ...
670 *
671 * After the loop, cpu is >= nr_cpu_ids.
672 */
673#define for_each_cpu_and(cpu, mask, and) \
674 for ((cpu) = -1; \
675 (cpu) = cpumask_next_and((cpu), (mask), (and)), \
676 (cpu) < nr_cpu_ids;)
677#endif /* SMP */
678
679#define CPU_BITS_NONE \
680{ \
681 [0 ... BITS_TO_LONGS(NR_CPUS)-1] = 0UL \
682}
683
684#define CPU_BITS_CPU0 \
685{ \
686 [0] = 1UL \
687}
688
689/**
690 * cpumask_set_cpu - set a cpu in a cpumask
691 * @cpu: cpu number (< nr_cpu_ids)
692 * @dstp: the cpumask pointer
693 */
694static inline void cpumask_set_cpu(unsigned int cpu, struct cpumask *dstp)
695{
696 set_bit(cpumask_check(cpu), cpumask_bits(dstp));
697}
698
699/**
700 * cpumask_clear_cpu - clear a cpu in a cpumask
701 * @cpu: cpu number (< nr_cpu_ids)
702 * @dstp: the cpumask pointer
703 */
704static inline void cpumask_clear_cpu(int cpu, struct cpumask *dstp)
705{
706 clear_bit(cpumask_check(cpu), cpumask_bits(dstp));
707}
708
709/**
710 * cpumask_test_cpu - test for a cpu in a cpumask
711 * @cpu: cpu number (< nr_cpu_ids)
712 * @cpumask: the cpumask pointer
713 *
714 * No static inline type checking - see Subtlety (1) above.
715 */
716#define cpumask_test_cpu(cpu, cpumask) \
717 test_bit(cpumask_check(cpu), (cpumask)->bits)
718
719/**
720 * cpumask_test_and_set_cpu - atomically test and set a cpu in a cpumask
721 * @cpu: cpu number (< nr_cpu_ids)
722 * @cpumask: the cpumask pointer
723 *
724 * test_and_set_bit wrapper for cpumasks.
725 */
726static inline int cpumask_test_and_set_cpu(int cpu, struct cpumask *cpumask)
727{
728 return test_and_set_bit(cpumask_check(cpu), cpumask_bits(cpumask));
729}
730
731/**
732 * cpumask_setall - set all cpus (< nr_cpu_ids) in a cpumask
733 * @dstp: the cpumask pointer
734 */
735static inline void cpumask_setall(struct cpumask *dstp)
736{
737 bitmap_fill(cpumask_bits(dstp), nr_cpumask_bits);
738}
739
740/**
741 * cpumask_clear - clear all cpus (< nr_cpu_ids) in a cpumask
742 * @dstp: the cpumask pointer
743 */
744static inline void cpumask_clear(struct cpumask *dstp)
745{
746 bitmap_zero(cpumask_bits(dstp), nr_cpumask_bits);
747}
748
749/**
750 * cpumask_and - *dstp = *src1p & *src2p
751 * @dstp: the cpumask result
752 * @src1p: the first input
753 * @src2p: the second input
754 */
755static inline void cpumask_and(struct cpumask *dstp,
756 const struct cpumask *src1p,
757 const struct cpumask *src2p)
758{
759 bitmap_and(cpumask_bits(dstp), cpumask_bits(src1p),
760 cpumask_bits(src2p), nr_cpumask_bits);
761}
762
763/**
764 * cpumask_or - *dstp = *src1p | *src2p
765 * @dstp: the cpumask result
766 * @src1p: the first input
767 * @src2p: the second input
768 */
769static inline void cpumask_or(struct cpumask *dstp, const struct cpumask *src1p,
770 const struct cpumask *src2p)
771{
772 bitmap_or(cpumask_bits(dstp), cpumask_bits(src1p),
773 cpumask_bits(src2p), nr_cpumask_bits);
774}
775
776/**
777 * cpumask_xor - *dstp = *src1p ^ *src2p
778 * @dstp: the cpumask result
779 * @src1p: the first input
780 * @src2p: the second input
781 */
782static inline void cpumask_xor(struct cpumask *dstp,
783 const struct cpumask *src1p,
784 const struct cpumask *src2p)
785{
786 bitmap_xor(cpumask_bits(dstp), cpumask_bits(src1p),
787 cpumask_bits(src2p), nr_cpumask_bits);
788}
789
790/**
791 * cpumask_andnot - *dstp = *src1p & ~*src2p
792 * @dstp: the cpumask result
793 * @src1p: the first input
794 * @src2p: the second input
795 */
796static inline void cpumask_andnot(struct cpumask *dstp,
797 const struct cpumask *src1p,
798 const struct cpumask *src2p)
799{
800 bitmap_andnot(cpumask_bits(dstp), cpumask_bits(src1p),
801 cpumask_bits(src2p), nr_cpumask_bits);
802}
803
804/**
805 * cpumask_complement - *dstp = ~*srcp
806 * @dstp: the cpumask result
807 * @srcp: the input to invert
808 */
809static inline void cpumask_complement(struct cpumask *dstp,
810 const struct cpumask *srcp)
811{
812 bitmap_complement(cpumask_bits(dstp), cpumask_bits(srcp),
813 nr_cpumask_bits);
814}
815
816/**
817 * cpumask_equal - *src1p == *src2p
818 * @src1p: the first input
819 * @src2p: the second input
820 */
821static inline bool cpumask_equal(const struct cpumask *src1p,
822 const struct cpumask *src2p)
823{
824 return bitmap_equal(cpumask_bits(src1p), cpumask_bits(src2p),
825 nr_cpumask_bits);
826}
827
828/**
829 * cpumask_intersects - (*src1p & *src2p) != 0
830 * @src1p: the first input
831 * @src2p: the second input
832 */
833static inline bool cpumask_intersects(const struct cpumask *src1p,
834 const struct cpumask *src2p)
835{
836 return bitmap_intersects(cpumask_bits(src1p), cpumask_bits(src2p),
837 nr_cpumask_bits);
838}
839
840/**
841 * cpumask_subset - (*src1p & ~*src2p) == 0
842 * @src1p: the first input
843 * @src2p: the second input
844 */
845static inline int cpumask_subset(const struct cpumask *src1p,
846 const struct cpumask *src2p)
847{
848 return bitmap_subset(cpumask_bits(src1p), cpumask_bits(src2p),
849 nr_cpumask_bits);
850}
851
852/**
853 * cpumask_empty - *srcp == 0
854 * @srcp: the cpumask to that all cpus < nr_cpu_ids are clear.
855 */
856static inline bool cpumask_empty(const struct cpumask *srcp)
857{
858 return bitmap_empty(cpumask_bits(srcp), nr_cpumask_bits);
859}
860
861/**
862 * cpumask_full - *srcp == 0xFFFFFFFF...
863 * @srcp: the cpumask to that all cpus < nr_cpu_ids are set.
864 */
865static inline bool cpumask_full(const struct cpumask *srcp)
866{
867 return bitmap_full(cpumask_bits(srcp), nr_cpumask_bits);
868}
869
870/**
871 * cpumask_weight - Count of bits in *srcp
872 * @srcp: the cpumask to count bits (< nr_cpu_ids) in.
873 */
874static inline unsigned int cpumask_weight(const struct cpumask *srcp)
875{
876 return bitmap_weight(cpumask_bits(srcp), nr_cpumask_bits);
877}
878
879/**
880 * cpumask_shift_right - *dstp = *srcp >> n
881 * @dstp: the cpumask result
882 * @srcp: the input to shift
883 * @n: the number of bits to shift by
884 */
885static inline void cpumask_shift_right(struct cpumask *dstp,
886 const struct cpumask *srcp, int n)
887{
888 bitmap_shift_right(cpumask_bits(dstp), cpumask_bits(srcp), n,
889 nr_cpumask_bits);
890}
891
892/**
893 * cpumask_shift_left - *dstp = *srcp << n
894 * @dstp: the cpumask result
895 * @srcp: the input to shift
896 * @n: the number of bits to shift by
897 */
898static inline void cpumask_shift_left(struct cpumask *dstp,
899 const struct cpumask *srcp, int n)
900{
901 bitmap_shift_left(cpumask_bits(dstp), cpumask_bits(srcp), n,
902 nr_cpumask_bits);
903}
904
905/**
906 * cpumask_copy - *dstp = *srcp
907 * @dstp: the result
908 * @srcp: the input cpumask
909 */
910static inline void cpumask_copy(struct cpumask *dstp,
911 const struct cpumask *srcp)
912{
913 bitmap_copy(cpumask_bits(dstp), cpumask_bits(srcp), nr_cpumask_bits);
914}
915
916/**
917 * cpumask_any - pick a "random" cpu from *srcp
918 * @srcp: the input cpumask
919 *
920 * Returns >= nr_cpu_ids if no cpus set.
921 */
922#define cpumask_any(srcp) cpumask_first(srcp)
923
924/**
925 * cpumask_first_and - return the first cpu from *srcp1 & *srcp2
926 * @src1p: the first input
927 * @src2p: the second input
928 *
929 * Returns >= nr_cpu_ids if no cpus set in both. See also cpumask_next_and().
930 */
931#define cpumask_first_and(src1p, src2p) cpumask_next_and(-1, (src1p), (src2p))
932
933/**
934 * cpumask_any_and - pick a "random" cpu from *mask1 & *mask2
935 * @mask1: the first input cpumask
936 * @mask2: the second input cpumask
937 *
938 * Returns >= nr_cpu_ids if no cpus set.
939 */
940#define cpumask_any_and(mask1, mask2) cpumask_first_and((mask1), (mask2))
941
942/**
943 * cpumask_of - the cpumask containing just a given cpu
944 * @cpu: the cpu (<= nr_cpu_ids)
945 */
946#define cpumask_of(cpu) (get_cpu_mask(cpu))
947
948/**
949 * to_cpumask - convert an NR_CPUS bitmap to a struct cpumask *
950 * @bitmap: the bitmap
951 *
952 * There are a few places where cpumask_var_t isn't appropriate and
953 * static cpumasks must be used (eg. very early boot), yet we don't
954 * expose the definition of 'struct cpumask'.
955 *
956 * This does the conversion, and can be used as a constant initializer.
957 */
958#define to_cpumask(bitmap) \
959 ((struct cpumask *)(1 ? (bitmap) \
960 : (void *)sizeof(__check_is_bitmap(bitmap))))
961
962static inline int __check_is_bitmap(const unsigned long *bitmap)
963{
964 return 1;
965}
966
967/**
968 * cpumask_size - size to allocate for a 'struct cpumask' in bytes
969 *
970 * This will eventually be a runtime variable, depending on nr_cpu_ids.
971 */
972static inline size_t cpumask_size(void)
973{
974 /* FIXME: Once all cpumask assignments are eliminated, this
975 * can be nr_cpumask_bits */
976 return BITS_TO_LONGS(NR_CPUS) * sizeof(long);
977}
978
979/*
980 * cpumask_var_t: struct cpumask for stack usage.
981 *
982 * Oh, the wicked games we play! In order to make kernel coding a
983 * little more difficult, we typedef cpumask_var_t to an array or a
984 * pointer: doing &mask on an array is a noop, so it still works.
985 *
986 * ie.
987 * cpumask_var_t tmpmask;
988 * if (!alloc_cpumask_var(&tmpmask, GFP_KERNEL))
989 * return -ENOMEM;
990 *
991 * ... use 'tmpmask' like a normal struct cpumask * ...
992 *
993 * free_cpumask_var(tmpmask);
994 */
995#ifdef CONFIG_CPUMASK_OFFSTACK
996typedef struct cpumask *cpumask_var_t;
997
998bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags);
999void alloc_bootmem_cpumask_var(cpumask_var_t *mask);
1000void free_cpumask_var(cpumask_var_t mask);
1001void free_bootmem_cpumask_var(cpumask_var_t mask);
1002
1003#else
1004typedef struct cpumask cpumask_var_t[1];
1005
1006static inline bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
1007{
1008 return true;
1009}
1010
1011static inline void alloc_bootmem_cpumask_var(cpumask_var_t *mask)
1012{
1013}
1014
1015static inline void free_cpumask_var(cpumask_var_t mask)
1016{
1017}
1018
1019static inline void free_bootmem_cpumask_var(cpumask_var_t mask)
1020{
1021}
1022#endif /* CONFIG_CPUMASK_OFFSTACK */
1023
1024/* The pointer versions of the maps, these will become the primary versions. */
1025#define cpu_possible_mask ((const struct cpumask *)&cpu_possible_map)
1026#define cpu_online_mask ((const struct cpumask *)&cpu_online_map)
1027#define cpu_present_mask ((const struct cpumask *)&cpu_present_map)
1028#define cpu_active_mask ((const struct cpumask *)&cpu_active_map)
1029
1030/* It's common to want to use cpu_all_mask in struct member initializers,
1031 * so it has to refer to an address rather than a pointer. */
1032extern const DECLARE_BITMAP(cpu_all_bits, NR_CPUS);
1033#define cpu_all_mask to_cpumask(cpu_all_bits)
1034
1035/* First bits of cpu_bit_bitmap are in fact unset. */
1036#define cpu_none_mask to_cpumask(cpu_bit_bitmap[0])
1037
1038/* Wrappers for arch boot code to manipulate normally-constant masks */
1039static inline void set_cpu_possible(unsigned int cpu, bool possible)
1040{
1041 if (possible)
1042 cpumask_set_cpu(cpu, &cpu_possible_map);
1043 else
1044 cpumask_clear_cpu(cpu, &cpu_possible_map);
1045}
1046
1047static inline void set_cpu_present(unsigned int cpu, bool present)
1048{
1049 if (present)
1050 cpumask_set_cpu(cpu, &cpu_present_map);
1051 else
1052 cpumask_clear_cpu(cpu, &cpu_present_map);
1053}
1054
1055static inline void set_cpu_online(unsigned int cpu, bool online)
1056{
1057 if (online)
1058 cpumask_set_cpu(cpu, &cpu_online_map);
1059 else
1060 cpumask_clear_cpu(cpu, &cpu_online_map);
1061}
1062
1063static inline void set_cpu_active(unsigned int cpu, bool active)
1064{
1065 if (active)
1066 cpumask_set_cpu(cpu, &cpu_active_map);
1067 else
1068 cpumask_clear_cpu(cpu, &cpu_active_map);
1069}
1070
1071static inline void init_cpu_present(const struct cpumask *src)
1072{
1073 cpumask_copy(&cpu_present_map, src);
1074}
1075
1076static inline void init_cpu_possible(const struct cpumask *src)
1077{
1078 cpumask_copy(&cpu_possible_map, src);
1079}
1080
1081static inline void init_cpu_online(const struct cpumask *src)
1082{
1083 cpumask_copy(&cpu_online_map, src);
1084}
530#endif /* __LINUX_CPUMASK_H */ 1085#endif /* __LINUX_CPUMASK_H */
diff --git a/include/linux/smp.h b/include/linux/smp.h
index 2e4d58b26c06..3f9a60043a97 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -64,8 +64,17 @@ extern void smp_cpus_done(unsigned int max_cpus);
64 * Call a function on all other processors 64 * Call a function on all other processors
65 */ 65 */
66int smp_call_function(void(*func)(void *info), void *info, int wait); 66int smp_call_function(void(*func)(void *info), void *info, int wait);
67/* Deprecated: use smp_call_function_many() which uses a cpumask ptr. */
67int smp_call_function_mask(cpumask_t mask, void(*func)(void *info), void *info, 68int smp_call_function_mask(cpumask_t mask, void(*func)(void *info), void *info,
68 int wait); 69 int wait);
70
71static inline void smp_call_function_many(const struct cpumask *mask,
72 void (*func)(void *info), void *info,
73 int wait)
74{
75 smp_call_function_mask(*mask, func, info, wait);
76}
77
69int smp_call_function_single(int cpuid, void (*func) (void *info), void *info, 78int smp_call_function_single(int cpuid, void (*func) (void *info), void *info,
70 int wait); 79 int wait);
71void __smp_call_function_single(int cpuid, struct call_single_data *data); 80void __smp_call_function_single(int cpuid, struct call_single_data *data);
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index 89a5a1231ffb..b36291130f22 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -240,4 +240,12 @@ void cancel_rearming_delayed_work(struct delayed_work *work)
240 cancel_delayed_work_sync(work); 240 cancel_delayed_work_sync(work);
241} 241}
242 242
243#ifndef CONFIG_SMP
244static inline long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg)
245{
246 return fn(arg);
247}
248#else
249long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg);
250#endif /* CONFIG_SMP */
243#endif 251#endif