SystemTap: copy.c Source File

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