| /drivers/ddk/Makefile |
|---|
| 12,6 → 12,7 |
| DEFINES = -DKOLIBRI -D__KERNEL__ -DCONFIG_X86_32 -DCONFIG_DMI -DCONFIG_TINY_RCU |
| DEFINES+= -DCONFIG_X86_L1_CACHE_SHIFT=6 -DCONFIG_ARCH_HAS_CACHE_LINE_SIZE |
| DEFINES+= -DCONFIG_PRINTK |
| CFLAGS = -c -Os $(INCLUDES) $(DEFINES) -march=i686 -fomit-frame-pointer -fno-builtin-printf \ |
| -mno-stack-arg-probe -mpreferred-stack-boundary=2 -mincoming-stack-boundary=2 -fno-ident |
| /drivers/ddk/linux/scatterlist.c |
|---|
| 349,9 → 349,70 |
| } |
| EXPORT_SYMBOL(sg_alloc_table); |
| /** |
| * sg_alloc_table_from_pages - Allocate and initialize an sg table from |
| * an array of pages |
| * @sgt: The sg table header to use |
| * @pages: Pointer to an array of page pointers |
| * @n_pages: Number of pages in the pages array |
| * @offset: Offset from start of the first page to the start of a buffer |
| * @size: Number of valid bytes in the buffer (after offset) |
| * @gfp_mask: GFP allocation mask |
| * |
| * Description: |
| * Allocate and initialize an sg table from a list of pages. Contiguous |
| * ranges of the pages are squashed into a single scatterlist node. A user |
| * may provide an offset at a start and a size of valid data in a buffer |
| * specified by the page array. The returned sg table is released by |
| * sg_free_table. |
| * |
| * Returns: |
| * 0 on success, negative error on failure |
| */ |
| int sg_alloc_table_from_pages(struct sg_table *sgt, |
| struct page **pages, unsigned int n_pages, |
| unsigned long offset, unsigned long size, |
| gfp_t gfp_mask) |
| { |
| unsigned int chunks; |
| unsigned int i; |
| unsigned int cur_page; |
| int ret; |
| struct scatterlist *s; |
| /* compute number of contiguous chunks */ |
| chunks = 1; |
| for (i = 1; i < n_pages; ++i) |
| if (page_to_pfn(pages[i]) != page_to_pfn(pages[i - 1]) + 1) |
| ++chunks; |
| ret = sg_alloc_table(sgt, chunks, gfp_mask); |
| if (unlikely(ret)) |
| return ret; |
| /* merging chunks and putting them into the scatterlist */ |
| cur_page = 0; |
| for_each_sg(sgt->sgl, s, sgt->orig_nents, i) { |
| unsigned long chunk_size; |
| unsigned int j; |
| /* look for the end of the current chunk */ |
| for (j = cur_page + 1; j < n_pages; ++j) |
| if (page_to_pfn(pages[j]) != |
| page_to_pfn(pages[j - 1]) + 1) |
| break; |
| chunk_size = ((j - cur_page) << PAGE_SHIFT) - offset; |
| sg_set_page(s, pages[cur_page], min(size, chunk_size), offset); |
| size -= chunk_size; |
| offset = 0; |
| cur_page = j; |
| } |
| return 0; |
| } |
| EXPORT_SYMBOL(sg_alloc_table_from_pages); |
| void __sg_page_iter_start(struct sg_page_iter *piter, |
| struct scatterlist *sglist, unsigned int nents, |
| unsigned long pgoffset) |
| /drivers/ddk/stdio/vsprintf.c |
|---|
| 41,9 → 41,8 |
| #define KSTRTOX_OVERFLOW (1U << 31) |
| const char hex_asc[] = "0123456789abcdef"; |
| const char hex_asc_upper[] = "0123456789ABCDEF"; |
| /* Works only for digits and letters, but small and fast */ |
| #define TOLOWER(x) ((x) | 0x20) |
| 1080,6 → 1079,8 |
| * (legacy clock framework) of the clock |
| * - 'Cr' For a clock, it prints the current rate of the clock |
| * |
| * ** Please update also Documentation/printk-formats.txt when making changes ** |
| * |
| * Note: The difference between 'S' and 'F' is that on ia64 and ppc64 |
| * function pointers are really function descriptors, which contain a |
| * pointer to the real address. |
| 1088,7 → 1089,7 |
| char *pointer(const char *fmt, char *buf, char *end, void *ptr, |
| struct printf_spec spec) |
| { |
| int default_width = 2 * sizeof(void *) + (spec.flags & SPECIAL ? 2 : 0); |
| const int default_width = 2 * sizeof(void *); |
| if (!ptr && *fmt != 'K') { |
| /* |
| 1315,11 → 1316,10 |
| case 'n': |
| /* |
| * Since %n poses a greater security risk than utility, treat |
| * it as an invalid format specifier. Warn about its use so |
| * that new instances don't get added. |
| * Since %n poses a greater security risk than |
| * utility, treat it as any other invalid or |
| * unsupported format specifier. |
| */ |
| // WARN_ONCE(1, "Please remove ignored %%n in '%s'\n", fmt); |
| /* Fall-through */ |
| default: |
| 1357,42 → 1357,17 |
| * @fmt: The format string to use |
| * @args: Arguments for the format string |
| * |
| * This function follows C99 vsnprintf, but has some extensions: |
| * %pS output the name of a text symbol with offset |
| * %ps output the name of a text symbol without offset |
| * %pF output the name of a function pointer with its offset |
| * %pf output the name of a function pointer without its offset |
| * %pB output the name of a backtrace symbol with its offset |
| * %pR output the address range in a struct resource with decoded flags |
| * %pr output the address range in a struct resource with raw flags |
| * %pb output the bitmap with field width as the number of bits |
| * %pbl output the bitmap as range list with field width as the number of bits |
| * %pM output a 6-byte MAC address with colons |
| * %pMR output a 6-byte MAC address with colons in reversed order |
| * %pMF output a 6-byte MAC address with dashes |
| * %pm output a 6-byte MAC address without colons |
| * %pmR output a 6-byte MAC address without colons in reversed order |
| * %pI4 print an IPv4 address without leading zeros |
| * %pi4 print an IPv4 address with leading zeros |
| * %pI6 print an IPv6 address with colons |
| * %pi6 print an IPv6 address without colons |
| * %pI6c print an IPv6 address as specified by RFC 5952 |
| * %pIS depending on sa_family of 'struct sockaddr *' print IPv4/IPv6 address |
| * %piS depending on sa_family of 'struct sockaddr *' print IPv4/IPv6 address |
| * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper |
| * case. |
| * %*pE[achnops] print an escaped buffer |
| * %*ph[CDN] a variable-length hex string with a separator (supports up to 64 |
| * bytes of the input) |
| * %pC output the name (Common Clock Framework) or address (legacy clock |
| * framework) of a clock |
| * %pCn output the name (Common Clock Framework) or address (legacy clock |
| * framework) of a clock |
| * %pCr output the current rate of a clock |
| * %n is ignored |
| * This function generally follows C99 vsnprintf, but has some |
| * extensions and a few limitations: |
| * |
| * ** Please update Documentation/printk-formats.txt when making changes ** |
| * %n is unsupported |
| * %p* is handled by pointer() |
| * |
| * See pointer() or Documentation/printk-formats.txt for more |
| * extensive description. |
| * |
| * ** Please update the documentation in both places when making changes ** |
| * |
| * The return value is the number of characters which would |
| * be generated for the given input, excluding the trailing |
| * '\0', as per ISO C99. If you want to have the exact |
| 1490,10 → 1465,15 |
| break; |
| case FORMAT_TYPE_INVALID: |
| if (str < end) |
| *str = '%'; |
| ++str; |
| break; |
| /* |
| * Presumably the arguments passed gcc's type |
| * checking, but there is no safe or sane way |
| * for us to continue parsing the format and |
| * fetching from the va_list; the remaining |
| * specifiers and arguments would be out of |
| * sync. |
| */ |
| goto out; |
| default: |
| switch (spec.type) { |
| 1538,6 → 1518,7 |
| } |
| } |
| out: |
| if (size > 0) { |
| if (str < end) |
| *str = '\0'; |
| /drivers/include/linux/dma-buf.h |
|---|
| 154,6 → 154,36 |
| }; |
| /** |
| * struct dma_buf_export_info - holds information needed to export a dma_buf |
| * @exp_name: name of the exporter - useful for debugging. |
| * @owner: pointer to exporter module - used for refcounting kernel module |
| * @ops: Attach allocator-defined dma buf ops to the new buffer |
| * @size: Size of the buffer |
| * @flags: mode flags for the file |
| * @resv: reservation-object, NULL to allocate default one |
| * @priv: Attach private data of allocator to this buffer |
| * |
| * This structure holds the information required to export the buffer. Used |
| * with dma_buf_export() only. |
| */ |
| struct dma_buf_export_info { |
| const char *exp_name; |
| struct module *owner; |
| const struct dma_buf_ops *ops; |
| size_t size; |
| int flags; |
| struct reservation_object *resv; |
| void *priv; |
| }; |
| /** |
| * helper macro for exporters; zeros and fills in most common values |
| */ |
| #define DEFINE_DMA_BUF_EXPORT_INFO(a) \ |
| struct dma_buf_export_info a = { .exp_name = KBUILD_MODNAME, \ |
| .owner = THIS_MODULE } |
| /** |
| * get_dma_buf - convenience wrapper for get_file. |
| * @dmabuf: [in] pointer to dma_buf |
| * |
| /drivers/include/linux/file.h |
|---|
| 4,5 → 4,12 |
| #ifndef __LINUX_FILE_H |
| #define __LINUX_FILE_H |
| #include <linux/compiler.h> |
| #include <linux/types.h> |
| #include <linux/posix_types.h> |
| struct file; |
| extern void fput(struct file *); |
| extern struct file *fget(unsigned int fd); |
| #endif /* __LINUX_FILE_H */ |
| /drivers/include/linux/fs.h |
|---|
| 1,3 → 1,97 |
| #ifndef _LINUX_FS_H |
| #define _LINUX_FS_H |
| #include <linux/list.h> |
| #include <linux/bug.h> |
| #include <linux/mutex.h> |
| #include <linux/rwsem.h> |
| #define MAY_EXEC 0x00000001 |
| #define MAY_WRITE 0x00000002 |
| #define MAY_READ 0x00000004 |
| #define MAY_APPEND 0x00000008 |
| #define MAY_ACCESS 0x00000010 |
| #define MAY_OPEN 0x00000020 |
| #define MAY_CHDIR 0x00000040 |
| /* called from RCU mode, don't block */ |
| #define MAY_NOT_BLOCK 0x00000080 |
| /* |
| * Attribute flags. These should be or-ed together to figure out what |
| * has been changed! |
| */ |
| #define ATTR_MODE (1 << 0) |
| #define ATTR_UID (1 << 1) |
| #define ATTR_GID (1 << 2) |
| #define ATTR_SIZE (1 << 3) |
| #define ATTR_ATIME (1 << 4) |
| #define ATTR_MTIME (1 << 5) |
| #define ATTR_CTIME (1 << 6) |
| #define ATTR_ATIME_SET (1 << 7) |
| #define ATTR_MTIME_SET (1 << 8) |
| #define ATTR_FORCE (1 << 9) /* Not a change, but a change it */ |
| #define ATTR_ATTR_FLAG (1 << 10) |
| #define ATTR_KILL_SUID (1 << 11) |
| #define ATTR_KILL_SGID (1 << 12) |
| #define ATTR_FILE (1 << 13) |
| #define ATTR_KILL_PRIV (1 << 14) |
| #define ATTR_OPEN (1 << 15) /* Truncating from open(O_TRUNC) */ |
| #define ATTR_TIMES_SET (1 << 16) |
| /* |
| * inode->i_mutex nesting subclasses for the lock validator: |
| * |
| * 0: the object of the current VFS operation |
| * 1: parent |
| * 2: child/target |
| * 3: xattr |
| * 4: second non-directory |
| * 5: second parent (when locking independent directories in rename) |
| * |
| * I_MUTEX_NONDIR2 is for certain operations (such as rename) which lock two |
| * non-directories at once. |
| * |
| * The locking order between these classes is |
| * parent[2] -> child -> grandchild -> normal -> xattr -> second non-directory |
| */ |
| enum inode_i_mutex_lock_class |
| { |
| I_MUTEX_NORMAL, |
| I_MUTEX_PARENT, |
| I_MUTEX_CHILD, |
| I_MUTEX_XATTR, |
| I_MUTEX_NONDIR2, |
| I_MUTEX_PARENT2, |
| }; |
| struct file { |
| /* |
| * Protects f_ep_links, f_flags. |
| * Must not be taken from IRQ context. |
| */ |
| spinlock_t f_lock; |
| atomic_long_t f_count; |
| unsigned int f_flags; |
| fmode_t f_mode; |
| /* needed for tty driver, and maybe others */ |
| void *private_data; |
| struct page **pages; /* physical memory backend */ |
| unsigned int count; |
| unsigned int allocated; |
| void *vma; |
| } __attribute__((aligned(4))); /* lest something weird decides that 2 is OK */ |
| #define get_file_rcu(x) atomic_long_inc_not_zero(&(x)->f_count) |
| #define fput_atomic(x) atomic_long_add_unless(&(x)->f_count, -1, 1) |
| #define file_count(x) atomic_long_read(&(x)->f_count) |
| #define FL_POSIX 1 |
| #define FL_FLOCK 2 |
| #define FL_DELEG 4 /* NFSv4 delegation */ |
| #define FL_ACCESS 8 /* not trying to lock, just looking */ |
| #define FL_EXISTS 16 /* when unlocking, test for existence */ |
| #define FL_LEASE 32 /* lease held on this file */ |
| #define FL_CLOSE 64 /* unlock on close */ |
| #define FL_SLEEP 128 /* A blocking lock */ |
| #define FL_DOWNGRADE_PENDING 256 /* Lease is being downgraded */ |
| #define FL_UNLOCK_PENDING 512 /* Lease is being broken */ |
| #define FL_OFDLCK 1024 /* lock is "owned" by struct file */ |
| #define FL_LAYOUT 2048 /* outstanding pNFS layout */ |
| #endif /* _LINUX_FS_H */ |
| /drivers/include/linux/kernel.h |
|---|
| 684,14 → 684,6 |
| u64 raw; |
| }evhandle_t; |
| struct file |
| { |
| struct page **pages; /* physical memory backend */ |
| unsigned int count; |
| unsigned int allocated; |
| void *vma; |
| }; |
| struct vm_area_struct {}; |
| struct address_space {}; |
| 836,11 → 828,6 |
| case 4: |
| *(u32 __force *)to = *(u32 *)from; |
| return 0; |
| #ifdef CONFIG_64BIT |
| case 8: |
| *(u64 __force *)to = *(u64 *)from; |
| return 0; |
| #endif |
| default: |
| break; |
| } |
| 850,6 → 837,41 |
| return 0; |
| } |
| static __always_inline unsigned long |
| __copy_from_user(void *to, const void __user *from, unsigned long n) |
| { |
| if (__builtin_constant_p(n)) { |
| unsigned long ret; |
| switch (n) { |
| case 1: |
| *(u8 __force *)to = *(u8 *)from; |
| return 0; |
| case 2: |
| *(u16 __force *)to = *(u16 *)from; |
| return 0; |
| case 4: |
| *(u32 __force *)to = *(u32 *)from; |
| return 0; |
| default: |
| break; |
| } |
| } |
| __builtin_memcpy((void __force *)to, from, n); |
| } |
| static inline long copy_from_user(void *to, |
| const void __user * from, unsigned long n) |
| { |
| return __copy_from_user(to, from, n); |
| } |
| static inline long copy_to_user(void __user *to, |
| const void *from, unsigned long n) |
| { |
| return __copy_to_user(to, from, n); |
| } |
| void *kmap(struct page *page); |
| void *kmap_atomic(struct page *page); |
| void kunmap(struct page *page); |
| /drivers/include/linux/workqueue.h |
|---|
| 218,6 → 218,9 |
| struct workqueue_struct *alloc_workqueue_key(const char *fmt, |
| unsigned int flags, int max_active); |
| struct workqueue_struct *alloc_workqueue(const char *fmt, |
| unsigned int flags, |
| int max_active); |
| /** |
| * alloc_ordered_workqueue - allocate an ordered workqueue |