From e32551b18f4560056d2d482f5e1505b1b98fa82a Mon Sep 17 00:00:00 2001 From: hunt Date: Tue, 29 Mar 2005 18:07:58 +0000 Subject: *** empty log message *** --- runtime/docs/html/copy_8c-source.html | 301 ++++++++++++++++++---------------- 1 file changed, 156 insertions(+), 145 deletions(-) (limited to 'runtime/docs/html/copy_8c-source.html') diff --git a/runtime/docs/html/copy_8c-source.html b/runtime/docs/html/copy_8c-source.html index 3456380c..1d4f8652 100644 --- a/runtime/docs/html/copy_8c-source.html +++ b/runtime/docs/html/copy_8c-source.html @@ -4,148 +4,159 @@ -
Main Page | Data Structures | Directories | File List | Data Fields | Globals | Related Pages
-

copy.c

Go to the documentation of this file.
00001 /* -*- linux-c -*- */
-00002 /** @file copy.c
-00003  * @brief Functions to copy from user space.
-00004  */
-00005 
-00006 long _stp_strncpy_from_user(char *dst, const char __user *src, long count);
-00007 //static long __stp_strncpy_from_user(char *dst, const char __user *src, long count);
-00008 
-00009 #if defined (__i386__)
-00010 #define __stp_strncpy_from_user(dst,src,count,res)                         \
-00011 do {                                                                       \
-00012         int __d0, __d1, __d2;                                              \
-00013         __asm__ __volatile__(                                              \
-00014                 "       testl %1,%1\n"                                     \
-00015                 "       jz 2f\n"                                           \
-00016                 "0:     lodsb\n"                                           \
-00017                 "       stosb\n"                                           \
-00018                 "       testb %%al,%%al\n"                                 \
-00019                 "       jz 1f\n"                                           \
-00020                 "       decl %1\n"                                         \
-00021                 "       jnz 0b\n"                                          \
-00022                 "1:     subl %1,%0\n"                                      \
-00023                 "2:\n"                                                     \
-00024                 ".section .fixup,\"ax\"\n"                                 \
-00025                 "3:     movl %5,%0\n"                                      \
-00026                 "       jmp 2b\n"                                          \
-00027                 ".previous\n"                                              \
-00028                 ".section __ex_table,\"a\"\n"                              \
-00029                 "       .align 4\n"                                        \
-00030                 "       .long 0b,3b\n"                                     \
-00031                 ".previous"                                                \
-00032                 : "=d"(res), "=c"(count), "=&a" (__d0), "=&S" (__d1),      \
-00033                   "=&D" (__d2)                                             \
-00034                 : "i"(-EFAULT), "0"(count), "1"(count), "3"(src), "4"(dst) \
-00035                 : "memory");                                               \
-00036 } while (0)
-00037 #elif defined (__x86_64__)
-00038 #define __stp_strncpy_from_user(dst,src,count,res)                         \
-00039 do {                                                                       \
-00040         long __d0, __d1, __d2;                                             \
-00041         __asm__ __volatile__(                                              \
-00042                 "       testq %1,%1\n"                                     \
-00043                 "       jz 2f\n"                                           \
-00044                 "0:     lodsb\n"                                           \
-00045                 "       stosb\n"                                           \
-00046                 "       testb %%al,%%al\n"                                 \
-00047                 "       jz 1f\n"                                           \
-00048                 "       decq %1\n"                                         \
-00049                 "       jnz 0b\n"                                          \
-00050                 "1:     subq %1,%0\n"                                      \
-00051                 "2:\n"                                                     \
-00052                 ".section .fixup,\"ax\"\n"                                 \
-00053                 "3:     movq %5,%0\n"                                      \
-00054                 "       jmp 2b\n"                                          \
-00055                 ".previous\n"                                              \
-00056                 ".section __ex_table,\"a\"\n"                              \
-00057                 "       .align 8\n"                                        \
-00058                 "       .quad 0b,3b\n"                                     \
-00059                 ".previous"                                                \
-00060                 : "=r"(res), "=c"(count), "=&a" (__d0), "=&S" (__d1),      \
-00061                   "=&D" (__d2)                                             \
-00062                 : "i"(-EFAULT), "0"(count), "1"(count), "3"(src), "4"(dst) \
-00063                 : "memory");                                               \
-00064 } while (0)
-00065 #endif
-00066 
-00067 /** Copy a NULL-terminated string from userspace.
-00068  * On success, returns the length of the string (not including the trailing
-00069  * NULL).
-00070  *
-00071  * If access to userspace fails, returns -EFAULT (some data may have been
-00072  * copied).
-00073  * @param dst Destination address, in kernel space.  This buffer must be at
-00074  *         least <i>count</i> bytes long.
-00075  * @param src Source address, in user space.
-00076  * @param count Maximum number of bytes to copy, including the trailing NULL.
-00077  * 
-00078  * If <i>count</i> is smaller than the length of the string, copies 
-00079  * <i>count</i> bytes and returns <i>count</i>.
-00080  */
-00081 
-00082 long
-00083 _stp_strncpy_from_user(char *dst, const char __user *src, long count)
-00084 {
-00085         long res;
-00086         __stp_strncpy_from_user(dst, src, count, res);
-00087         return res;
-00088 }
-00089 
-00090 /** Copy a block of data from user space.
-00091  *
-00092  * If some data could not be copied, this function will pad the copied
-00093  * data to the requested size using zero bytes.
-00094 
-00095  * @param dst Destination address, in kernel space.
-00096  * @param src Source address, in user space.
-00097  * @param count Number of bytes to copy.
-00098  * @return number of bytes that could not be copied. On success, 
-00099  * this will be zero.
-00100  *
-00101  */
-00102 
-00103 unsigned long inline
-00104 _stp_copy_from_user (char *dst, const char __user *src, unsigned long count)
-00105 {
-00106         return __copy_from_user_inatomic(dst, src, count);
-00107 }
-00108 
-00109 /** Copy an argv from user space to a List.
-00110  *
-00111  * @param list A list.
-00112  * @param argv Source argv, in user space.
-00113  * @return number of elements in <i>list</i>
-00114  *
-00115  * @b Example:
-00116  * @include argv.c
-00117  */
-00118 
-00119 int _stp_copy_argv_from_user (MAP list, char __user *__user *argv)
-00120 {
-00121         char str[128];
-00122         char __user *vstr;
-00123         int len;
-00124 
-00125         if (argv)
-00126                 argv++;
-00127 
-00128         while (argv != NULL) {
-00129                 if (get_user (vstr, argv))
-00130                         break;
-00131                 
-00132                 if (vstr == NULL)
-00133                         break;
-00134                 
-00135                 len = _stp_strncpy_from_user(str, vstr, 128);
-00136                 str[len] = 0;
-00137                 _stp_list_add_str (list, str);
-00138                 argv++;
-00139         }
-00140         return list->num;
-00141 }
-
-Generated on Tue Mar 22 10:27:36 2005 for SystemTap. - +
Main Page | Modules | Data Structures | Directories | File List | Data Fields | Globals | Related Pages
+

copy.c

Go to the documentation of this file.
00001 #ifndef _COPY_C_
+00002 #define _COPY_C_
+00003 
+00004 /* -*- linux-c -*- */
+00005 /** @file copy.c
+00006  * @brief Functions to copy from user space.
+00007  */
+00008 
+00009 /** @addtogroup copy Functions to copy from user space.
+00010  * Functions to copy from user space.
+00011  * None of these functions will sleep (for example to allow pages
+00012  * to be swapped in). It is possible (although rare) that the data
+00013  * in user space will not present and these functions will return an error.
+00014  * @{
+00015  */
+00016 
+00017 long _stp_strncpy_from_user(char *dst, const char __user *src, long count);
+00018 //static long __stp_strncpy_from_user(char *dst, const char __user *src, long count);
+00019 
+00020 #if defined (__i386__)
+00021 #define __stp_strncpy_from_user(dst,src,count,res)                         \
+00022 do {                                                                       \
+00023         int __d0, __d1, __d2;                                              \
+00024         __asm__ __volatile__(                                              \
+00025                 "       testl %1,%1\n"                                     \
+00026                 "       jz 2f\n"                                           \
+00027                 "0:     lodsb\n"                                           \
+00028                 "       stosb\n"                                           \
+00029                 "       testb %%al,%%al\n"                                 \
+00030                 "       jz 1f\n"                                           \
+00031                 "       decl %1\n"                                         \
+00032                 "       jnz 0b\n"                                          \
+00033                 "1:     subl %1,%0\n"                                      \
+00034                 "2:\n"                                                     \
+00035                 ".section .fixup,\"ax\"\n"                                 \
+00036                 "3:     movl %5,%0\n"                                      \
+00037                 "       jmp 2b\n"                                          \
+00038                 ".previous\n"                                              \
+00039                 ".section __ex_table,\"a\"\n"                              \
+00040                 "       .align 4\n"                                        \
+00041                 "       .long 0b,3b\n"                                     \
+00042                 ".previous"                                                \
+00043                 : "=d"(res), "=c"(count), "=&a" (__d0), "=&S" (__d1),      \
+00044                   "=&D" (__d2)                                             \
+00045                 : "i"(-EFAULT), "0"(count), "1"(count), "3"(src), "4"(dst) \
+00046                 : "memory");                                               \
+00047 } while (0)
+00048 #elif defined (__x86_64__)
+00049 #define __stp_strncpy_from_user(dst,src,count,res)                         \
+00050 do {                                                                       \
+00051         long __d0, __d1, __d2;                                             \
+00052         __asm__ __volatile__(                                              \
+00053                 "       testq %1,%1\n"                                     \
+00054                 "       jz 2f\n"                                           \
+00055                 "0:     lodsb\n"                                           \
+00056                 "       stosb\n"                                           \
+00057                 "       testb %%al,%%al\n"                                 \
+00058                 "       jz 1f\n"                                           \
+00059                 "       decq %1\n"                                         \
+00060                 "       jnz 0b\n"                                          \
+00061                 "1:     subq %1,%0\n"                                      \
+00062                 "2:\n"                                                     \
+00063                 ".section .fixup,\"ax\"\n"                                 \
+00064                 "3:     movq %5,%0\n"                                      \
+00065                 "       jmp 2b\n"                                          \
+00066                 ".previous\n"                                              \
+00067                 ".section __ex_table,\"a\"\n"                              \
+00068                 "       .align 8\n"                                        \
+00069                 "       .quad 0b,3b\n"                                     \
+00070                 ".previous"                                                \
+00071                 : "=r"(res), "=c"(count), "=&a" (__d0), "=&S" (__d1),      \
+00072                   "=&D" (__d2)                                             \
+00073                 : "i"(-EFAULT), "0"(count), "1"(count), "3"(src), "4"(dst) \
+00074                 : "memory");                                               \
+00075 } while (0)
+00076 #endif
+00077 
+00078 /** Copy a NULL-terminated string from userspace.
+00079  * On success, returns the length of the string (not including the trailing
+00080  * NULL).
+00081  *
+00082  * If access to userspace fails, returns -EFAULT (some data may have been
+00083  * copied).
+00084  * @param dst Destination address, in kernel space.  This buffer must be at
+00085  *         least <i>count</i> bytes long.
+00086  * @param src Source address, in user space.
+00087  * @param count Maximum number of bytes to copy, including the trailing NULL.
+00088  * 
+00089  * If <i>count</i> is smaller than the length of the string, copies 
+00090  * <i>count</i> bytes and returns <i>count</i>.
+00091  */
+00092 
+00093 long
+00094 _stp_strncpy_from_user(char *dst, const char __user *src, long count)
+00095 {
+00096         long res;
+00097         __stp_strncpy_from_user(dst, src, count, res);
+00098         return res;
+00099 }
+00100 
+00101 /** Copy a block of data from user space.
+00102  *
+00103  * If some data could not be copied, this function will pad the copied
+00104  * data to the requested size using zero bytes.
+00105 
+00106  * @param dst Destination address, in kernel space.
+00107  * @param src Source address, in user space.
+00108  * @param count Number of bytes to copy.
+00109  * @return number of bytes that could not be copied. On success, 
+00110  * this will be zero.
+00111  *
+00112  */
+00113 
+00114 unsigned long inline
+00115 _stp_copy_from_user (char *dst, const char __user *src, unsigned long count)
+00116 {
+00117         return __copy_from_user_inatomic(dst, src, count);
+00118 }
+00119 
+00120 /** Copy an argv from user space to a List.
+00121  *
+00122  * @param list A list.
+00123  * @param argv Source argv, in user space.
+00124  * @return number of elements in <i>list</i>
+00125  *
+00126  * @b Example:
+00127  * @include argv.c
+00128  */
+00129 
+00130 int _stp_copy_argv_from_user (MAP list, char __user *__user *argv)
+00131 {
+00132         char str[128];
+00133         char __user *vstr;
+00134         int len;
+00135 
+00136         if (argv)
+00137                 argv++;
+00138 
+00139         while (argv != NULL) {
+00140                 if (get_user (vstr, argv))
+00141                         break;
+00142                 
+00143                 if (vstr == NULL)
+00144                         break;
+00145                 
+00146                 len = _stp_strncpy_from_user(str, vstr, 128);
+00147                 str[len] = 0;
+00148                 _stp_list_add_str (list, str);
+00149                 argv++;
+00150         }
+00151         return list->num;
+00152 }
+00153 /** @} */
+00154 #endif /* _COPY_C_ */
+
-- cgit