ReactOS  0.4.14-dev-606-g14ebc0b
module.h
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYRIGHT.TXT
3  * PROJECT: Ext2 File System Driver for WinNT/2K/XP
4  * FILE: Modules.h
5  * PURPOSE: Header file: nls structures & linux kernel ...
6  * PROGRAMMER: Matt Wu <mattwu@163.com>
7  * HOMEPAGE: http://www.ext2fsd.com
8  * UPDATE HISTORY:
9  */
10 
11 #ifndef _EXT2_MODULE_HEADER_
12 #define _EXT2_MODULE_HEADER_
13 
14 /* INCLUDES *************************************************************/
15 
16 #include <linux/types.h>
17 #include <linux/errno.h>
18 #include <linux/rbtree.h>
19 #include <linux/fs.h>
20 #include <linux/log2.h>
21 
22 #if _WIN32_WINNT <= 0x500
23 #define _WIN2K_TARGET_ 1
24 #endif
25 
26 /* STRUCTS ******************************************************/
27 
28 #ifndef offsetof
29 # define offsetof(type, member) ((ULONG_PTR)&(((type *)0)->member))
30 #endif
31 
32 #ifndef container_of
33 #define container_of(ptr, type, member) \
34  ((type *)((char *)ptr - (char *)offsetof(type, member)))
35 #endif
36 
37 //
38 // Byte order swapping routines
39 //
40 
41 /* use the runtime routine or compiler's implementation */
42 #if (defined(_M_IX86) && (_MSC_FULL_VER > 13009037)) || \
43  ((defined(_M_AMD64) || defined(_M_IA64)) && \
44  (_MSC_FULL_VER > 13009175))
45 #ifdef __cplusplus
46 extern "C" {
47 #endif
48  unsigned short __cdecl _byteswap_ushort(unsigned short);
49  unsigned long __cdecl _byteswap_ulong (unsigned long);
50  unsigned __int64 __cdecl _byteswap_uint64(unsigned __int64);
51 #ifdef __cplusplus
52 }
53 #endif
54 #pragma intrinsic(_byteswap_ushort)
55 #pragma intrinsic(_byteswap_ulong)
56 #pragma intrinsic(_byteswap_uint64)
57 
58 #define RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x))
59 #define RtlUlongByteSwap(_x) _byteswap_ulong((_x))
60 #define RtlUlonglongByteSwap(_x) _byteswap_uint64((_x))
61 
62 #elif !defined(__REACTOS__)
63 
64 USHORT
68 );
69 
70 ULONG
74 );
75 
80 );
81 #endif
82 
83 #define __swab16(x) RtlUshortByteSwap(x)
84 #define __swab32(x) RtlUlongByteSwap(x)
85 #define __swab64(x) RtlUlonglongByteSwap(x)
86 
87 #define __constant_swab32 __swab32
88 #define __constant_swab64 __swab64
89 
90 #define __constant_htonl(x) __constant_swab32((x))
91 #define __constant_ntohl(x) __constant_swab32((x))
92 #define __constant_htons(x) __constant_swab16((x))
93 #define __constant_ntohs(x) __constant_swab16((x))
94 #define __constant_cpu_to_le64(x) ((__u64)(x))
95 #define __constant_le64_to_cpu(x) ((__u64)(x))
96 #define __constant_cpu_to_le32(x) ((__u32)(x))
97 #define __constant_le32_to_cpu(x) ((__u32)(x))
98 #define __constant_cpu_to_le16(x) ((__u16)(x))
99 #define __constant_le16_to_cpu(x) ((__u16)(x))
100 #define __constant_cpu_to_be64(x) __constant_swab64((x))
101 #define __constant_be64_to_cpu(x) __constant_swab64((x))
102 #define __constant_cpu_to_be32(x) __constant_swab32((x))
103 #define __constant_be32_to_cpu(x) __constant_swab32((x))
104 #define __constant_cpu_to_be16(x) __constant_swab16((x))
105 #define __constant_be16_to_cpu(x) __constant_swab16((x))
106 #define __cpu_to_le64(x) ((__u64)(x))
107 #define __le64_to_cpu(x) ((__u64)(x))
108 #define __cpu_to_le32(x) ((__u32)(x))
109 #define __le32_to_cpu(x) ((__u32)(x))
110 #define __cpu_to_le16(x) ((__u16)(x))
111 #define __le16_to_cpu(x) ((__u16)(x))
112 #define __cpu_to_be64(x) __swab64((x))
113 #define __be64_to_cpu(x) __swab64((x))
114 #define __cpu_to_be32(x) __swab32((x))
115 #define __be32_to_cpu(x) __swab32((x))
116 #define __cpu_to_be16(x) __swab16((x))
117 #define __be16_to_cpu(x) __swab16((x))
118 #define __cpu_to_le64p(x) (*(__u64*)(x))
119 #define __le64_to_cpup(x) (*(__u64*)(x))
120 #define __cpu_to_le32p(x) (*(__u32*)(x))
121 #define __le32_to_cpup(x) (*(__u32*)(x))
122 #define __cpu_to_le16p(x) (*(__u16*)(x))
123 #define __le16_to_cpup(x) (*(__u16*)(x))
124 #define __cpu_to_be64p(x) __swab64p((x))
125 #define __be64_to_cpup(x) __swab64p((x))
126 #define __cpu_to_be32p(x) __swab32p((x))
127 #define __be32_to_cpup(x) __swab32p((x))
128 #define __cpu_to_be16p(x) __swab16p((x))
129 #define __be16_to_cpup(x) __swab16p((x))
130 #define __cpu_to_le64s(x) ((__s64)(x))
131 #define __le64_to_cpus(x) ((__s64)(x))
132 #define __cpu_to_le32s(x) ((__s32)(x))
133 #define __le32_to_cpus(x) ((__s32)(x))
134 #define __cpu_to_le16s(x) ((__s16)(x))
135 #define __le16_to_cpus(x) ((__s16)(x))
136 #define __cpu_to_be64s(x) __swab64s((x))
137 #define __be64_to_cpus(x) __swab64s((x))
138 #define __cpu_to_be32s(x) __swab32s((x))
139 #define __be32_to_cpus(x) __swab32s((x))
140 #define __cpu_to_be16s(x) __swab16s((x))
141 #define __be16_to_cpus(x) __swab16s((x))
142 
143 #ifndef cpu_to_le64
144 #define cpu_to_le64 __cpu_to_le64
145 #define le64_to_cpu __le64_to_cpu
146 #define cpu_to_le32 __cpu_to_le32
147 #define le32_to_cpu __le32_to_cpu
148 #define cpu_to_le16 __cpu_to_le16
149 #define le16_to_cpu __le16_to_cpu
150 #endif
151 
152 #define cpu_to_be64 __cpu_to_be64
153 #define be64_to_cpu __be64_to_cpu
154 #define cpu_to_be32 __cpu_to_be32
155 #define be32_to_cpu __be32_to_cpu
156 #define cpu_to_be16 __cpu_to_be16
157 #define be16_to_cpu __be16_to_cpu
158 #define cpu_to_le64p __cpu_to_le64p
159 #define le64_to_cpup __le64_to_cpup
160 #define cpu_to_le32p __cpu_to_le32p
161 #define le32_to_cpup __le32_to_cpup
162 #define cpu_to_le16p __cpu_to_le16p
163 #define le16_to_cpup __le16_to_cpup
164 #define cpu_to_be64p __cpu_to_be64p
165 #define be64_to_cpup __be64_to_cpup
166 #define cpu_to_be32p __cpu_to_be32p
167 #define be32_to_cpup __be32_to_cpup
168 #define cpu_to_be16p __cpu_to_be16p
169 #define be16_to_cpup __be16_to_cpup
170 #define cpu_to_le64s __cpu_to_le64s
171 #define le64_to_cpus __le64_to_cpus
172 #define cpu_to_le32s __cpu_to_le32s
173 #define le32_to_cpus __le32_to_cpus
174 #define cpu_to_le16s __cpu_to_le16s
175 #define le16_to_cpus __le16_to_cpus
176 #define cpu_to_be64s __cpu_to_be64s
177 #define be64_to_cpus __be64_to_cpus
178 #define cpu_to_be32s __cpu_to_be32s
179 #define be32_to_cpus __be32_to_cpus
180 #define cpu_to_be16s __cpu_to_be16s
181 #define be16_to_cpus __be16_to_cpus
182 
183 
184 static inline void le16_add_cpu(__le16 *var, u16 val)
185 {
186  *var = cpu_to_le16(le16_to_cpu(*var) + val);
187 }
188 
189 static inline void le32_add_cpu(__le32 *var, u32 val)
190 {
191  *var = cpu_to_le32(le32_to_cpu(*var) + val);
192 }
193 
194 static inline void le64_add_cpu(__le64 *var, u64 val)
195 {
196  *var = cpu_to_le64(le64_to_cpu(*var) + val);
197 }
198 
199 //
200 // Network to host byte swap functions
201 //
202 
203 #define ntohl(x) ( ( ( ( x ) & 0x000000ff ) << 24 ) | \
204  ( ( ( x ) & 0x0000ff00 ) << 8 ) | \
205  ( ( ( x ) & 0x00ff0000 ) >> 8 ) | \
206  ( ( ( x ) & 0xff000000 ) >> 24 ) )
207 
208 #define ntohs(x) ( ( ( ( x ) & 0xff00 ) >> 8 ) | \
209  ( ( ( x ) & 0x00ff ) << 8 ) )
210 
211 
212 #define htonl(x) ntohl(x)
213 #define htons(x) ntohs(x)
214 
215 
216 //
217 // kernel printk flags
218 //
219 
220 #define KERN_EMERG "<0>" /* system is unusable */
221 #define KERN_ALERT "<1>" /* action must be taken immediately */
222 #define KERN_CRIT "<2>" /* critical conditions */
223 #define KERN_ERR "<3>" /* error conditions */
224 #define KERN_WARNING "<4>" /* warning conditions */
225 #define KERN_NOTICE "<5>" /* normal but significant condition */
226 #define KERN_INFO "<6>" /* informational */
227 #define KERN_DEBUG "<7>" /* debug-level messages */
228 
229 #define printk DbgPrint
230 
231 /*
232  * error pointer
233  */
234 #define MAX_ERRNO 4095
235 #define IS_ERR_VALUE(x) ((x) >= (unsigned long)-MAX_ERRNO)
236 
237 static inline void *ERR_PTR(long error)
238 {
239  return (void *)(long_ptr_t) error;
240 }
241 
242 static inline long PTR_ERR(const void *ptr)
243 {
244  return (long)(long_ptr_t) ptr;
245 }
246 
247 static inline long IS_ERR(const void *ptr)
248 {
249  return IS_ERR_VALUE((unsigned long)(long_ptr_t)ptr);
250 }
251 
252 
253 #define BUG_ON(c) assert(!(c))
254 
255 #define WARN_ON(c) BUG_ON(c)
256 
257 //
258 // Linux module definitions
259 //
260 
261 #define likely
262 #define unlikely
263 
264 #define __init
265 #define __exit
266 
267 #define THIS_MODULE NULL
268 #define MODULE_LICENSE(x)
269 #define MODULE_ALIAS_NLS(x)
270 #define EXPORT_SYMBOL(x)
271 
272 
273 #define try_module_get(x) (TRUE)
274 #define module_put(x)
275 
276 #define module_init(X) int __init module_##X() {return X();}
277 #define module_exit(X) void __exit module_##X() {X();}
278 
279 #define DECLARE_INIT(X) int __init module_##X(void)
280 #define DECLARE_EXIT(X) void __exit module_##X(void)
281 
282 #define LOAD_MODULE(X) do { \
283  rc = module_##X(); \
284  } while(0)
285 
286 #define UNLOAD_MODULE(X) do { \
287  module_##X(); \
288  } while(0)
289 
290 #define LOAD_NLS LOAD_MODULE
291 #define UNLOAD_NLS UNLOAD_MODULE
292 
293 //
294 // spinlocks .....
295 //
296 
297 typedef struct _spinlock_t {
298 
301 } spinlock_t;
302 
303 #define spin_lock_init(sl) KeInitializeSpinLock(&((sl)->lock))
304 #define spin_lock(sl) KeAcquireSpinLock(&((sl)->lock), &((sl)->irql))
305 #define spin_unlock(sl) KeReleaseSpinLock(&((sl)->lock), (sl)->irql)
306 #define spin_lock_irqsave(sl, flags) do {spin_lock(sl); flags=(sl)->irql;} while(0)
307 #define spin_unlock_irqrestore(sl, flags) do {ASSERT((KIRQL)(flags)==(sl)->irql); spin_unlock(sl);} while(0)
308 
309 #define assert_spin_locked(x) do {} while(0)
310 
311 /*
312  * Does a critical section need to be broken due to another
313  * task waiting?: (technically does not depend on CONFIG_PREEMPT,
314  * but a general need for low latency)
315  */
316 static inline int spin_needbreak(spinlock_t *lock)
317 {
318 #ifdef CONFIG_PREEMPT
319  return spin_is_contended(lock);
320 #else
321  return 0;
322 #endif
323 }
324 
325 //
326 // bit operations
327 //
328 
338 static inline int set_bit(int nr, volatile unsigned long *addr)
339 {
340  addr += (nr >> ORDER_PER_LONG);
341  nr &= (BITS_PER_LONG - 1);
342 
343  return !!(InterlockedOr(addr, (1 << nr)) & (1 << nr));
344 }
345 
346 
357 static inline int clear_bit(int nr, volatile unsigned long *addr)
358 {
359  addr += (nr >> ORDER_PER_LONG);
360  nr &= (BITS_PER_LONG - 1);
361 
362  return !!(InterlockedAnd(addr, ~(1 << nr)) & (1 << nr));
363 }
364 
373 static inline int test_and_clear_bit(int nr, volatile unsigned long *addr)
374 {
375  return clear_bit(nr, addr);
376 }
377 
378 /*
379  * test
380  */
381 static int test_bit(int nr, volatile const unsigned long *addr)
382 {
383  return !!((1 << (nr & (BITS_PER_LONG - 1))) &
384  (addr[nr >> ORDER_PER_LONG]));
385 }
386 
395 static inline int test_and_set_bit(int nr, volatile unsigned long *addr)
396 {
397  return set_bit(nr, addr);
398 }
399 
400 //
401 // list definition ...
402 //
403 
404 #include <linux/list.h>
405 
406 
407 /*********************************************
408  * linux scheduler related structures *
409 *********************************************/
410 
411 //
412 // task structure
413 //
414 
415 #define TASK_INTERRUPTIBLE 1
416 #define TASK_UNINTERRUPTIBLE 2
417 
418 struct task_struct {
421  char comm[32];
422  void * journal_info;
423 };
424 
425 extern struct task_struct *current;
426 
427 //
428 // scheduler routines
429 //
430 
431 
432 static inline int cond_resched() {
433  return FALSE;
434 }
435 static inline int need_resched() {
436  return FALSE;
437 }
438 
439 #define yield() do {} while(0)
440 #define might_sleep() do {} while(0)
441 
442 //
443 // mutex
444 //
445 
446 typedef struct mutex {
448 } mutex_t;
449 
450 #define mutex_init(x) ExInitializeFastMutex(&((x)->lock))
451 #define mutex_lock(x) ExAcquireFastMutex(&((x)->lock))
452 #define mutex_unlock(x) ExReleaseFastMutex(&((x)->lock))
453 
454 
455 //
456 // wait_queue
457 //
458 
459 
461 
462 #define WQ_FLAG_EXCLUSIVE 0x01
463 #define WQ_FLAG_AUTO_REMOVAL 0x02
464 
465 struct __wait_queue {
466  unsigned int flags;
467  void * private;
470 };
471 
472 
473 #define DEFINE_WAIT(name) \
474  wait_queue_t name = (PVOID)wait_queue_create();
475 
476 /*
477 struct wait_bit_key {
478  void *flags;
479  int bit_nr;
480 };
481 
482 struct wait_bit_queue {
483  struct wait_bit_key key;
484  wait_queue_t wait;
485 };
486 */
487 
491 };
493 
494 #define is_sync_wait(wait) (TRUE)
495 #define set_current_state(state) do {} while(0)
496 #define __set_current_state(state) do {} while(0)
497 
500 
501 
502 /*
503  * Waitqueues which are removed from the waitqueue_head at wakeup time
504  */
506 void wait_queue_destroy(struct __wait_queue *);
507 
511 int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
512 int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
513 
514 
515 //
516 // timer structure
517 //
518 
519 struct timer_list {
520  struct list_head entry;
521  unsigned long expires;
522 
523  void (*function)(unsigned long);
524  unsigned long data;
525 
526 #ifdef CONFIG_TIMER_STATS
527  void *start_site;
528  char start_comm[16];
529  int start_pid;
530 #endif
531 };
532 
533 
534 typedef struct kmem_cache kmem_cache_t;
535 
536 struct block_device {
537 
538  unsigned long bd_flags; /* flags */
539  atomic_t bd_count; /* reference count */
540  PDEVICE_OBJECT bd_dev; /* device object */
541  ANSI_STRING bd_name; /* name in ansi string */
542  DISK_GEOMETRY bd_geo; /* disk geometry */
543  PARTITION_INFORMATION bd_part; /* partition information */
544  void * bd_priv; /* pointers to EXT2_VCB
545  NULL if it's a journal dev */
546  PFILE_OBJECT bd_volume; /* streaming object file */
547  LARGE_MCB bd_extents; /* dirty extents */
548 
549  kmem_cache_t * bd_bh_cache;/* memory cache for buffer_head */
550  ERESOURCE bd_bh_lock; /* lock for bh tree and reaper list */
551  struct rb_root bd_bh_root; /* buffer_head red-black tree root */
552  LIST_ENTRY bd_bh_free; /* reaper list */
553  KEVENT bd_bh_notify; /* notification event for cleanup */
554 };
555 
556 //
557 // page information
558 //
559 
560 // vom trata paginile in felul urmator:
561 // alocam la sfarsitul structurii inca PAGE_SIZE octeti cand alocam o structura
562 // de tip pagina - acolo vor veni toate buffer-headurile
563 // deci -> page_address(page) = page + sizeof(page)
564 #define page_address(_page) ((char*)_page + sizeof(struct page))
565 
566 typedef struct page {
567  void *addr;
568  void *mapping;
569  void *private;
573 } mem_map_t;
574 
575 #define get_page(p) atomic_inc(&(p)->count)
576 
577 #define PG_locked 0 /* Page is locked. Don't touch. */
578 #define PG_error 1
579 #define PG_referenced 2
580 #define PG_uptodate 3
581 #define PG_dirty 4
582 #define PG_unused 5
583 #define PG_lru 6
584 #define PG_active 7
585 #define PG_slab 8
586 #define PG_skip 10
587 #define PG_highmem 11
588 #define PG_checked 12 /* kill me in 2.5.<early>. */
589 #define PG_arch_1 13
590 #define PG_reserved 14
591 #define PG_launder 15 /* written out by VM pressure.. */
592 #define PG_fs_1 16 /* Filesystem specific */
593 
594 #ifndef arch_set_page_uptodate
595 #define arch_set_page_uptodate(page)
596 #endif
597 
598 /* Make it prettier to test the above... */
599 #define UnlockPage(page) unlock_page(page)
600 #define Page_Uptodate(page) test_bit(PG_uptodate, &(page)->flags)
601 #define SetPageUptodate(page) \
602  do { \
603  arch_set_page_uptodate(page); \
604  set_bit(PG_uptodate, &(page)->flags); \
605  } while (0)
606 #define ClearPageUptodate(page) clear_bit(PG_uptodate, &(page)->flags)
607 #define PageDirty(page) test_bit(PG_dirty, &(page)->flags)
608 #define SetPageDirty(page) set_bit(PG_dirty, &(page)->flags)
609 #define ClearPageDirty(page) clear_bit(PG_dirty, &(page)->flags)
610 #define PageLocked(page) test_bit(PG_locked, &(page)->flags)
611 #define LockPage(page) set_bit(PG_locked, &(page)->flags)
612 #define TryLockPage(page) test_and_set_bit(PG_locked, &(page)->flags)
613 #define PageChecked(page) test_bit(PG_checked, &(page)->flags)
614 #define SetPageChecked(page) set_bit(PG_checked, &(page)->flags)
615 #define ClearPageChecked(page) clear_bit(PG_checked, &(page)->flags)
616 #define PageLaunder(page) test_bit(PG_launder, &(page)->flags)
617 #define SetPageLaunder(page) set_bit(PG_launder, &(page)->flags)
618 #define ClearPageLaunder(page) clear_bit(PG_launder, &(page)->flags)
619 #define ClearPageArch1(page) clear_bit(PG_arch_1, &(page)->flags)
620 
621 #define PageError(page) test_bit(PG_error, &(page)->flags)
622 #define SetPageError(page) set_bit(PG_error, &(page)->flags)
623 #define ClearPageError(page) clear_bit(PG_error, &(page)->flags)
624 #define PageReferenced(page) test_bit(PG_referenced, &(page)->flags)
625 #define SetPageReferenced(page) set_bit(PG_referenced, &(page)->flags)
626 #define ClearPageReferenced(page) clear_bit(PG_referenced, &(page)->flags)
627 
628 #define PageActive(page) test_bit(PG_active, &(page)->flags)
629 #define SetPageActive(page) set_bit(PG_active, &(page)->flags)
630 #define ClearPageActive(page) clear_bit(PG_active, &(page)->flags)
631 
632 
633 extern unsigned long __get_free_pages(unsigned int gfp_mask, unsigned int order);
634 #define __get_free_page(gfp_mask) \
635  __get_free_pages((gfp_mask),0)
636 
637 extern void __free_pages(struct page *page, unsigned int order);
638 extern void free_pages(unsigned long addr, unsigned int order);
639 
640 #define __free_page(page) __free_pages((page), 0)
641 #define free_page(addr) free_pages((addr),0)
642 
643 #ifndef __REACTOS__
644 extern void truncate_inode_pages(struct address_space *, loff_t);
645 #endif
646 
647 #define __GFP_HIGHMEM 0x02
648 
649 #define __GFP_WAIT 0x10 /* Can wait and reschedule? */
650 #define __GFP_HIGH 0x20 /* Should access emergency pools? */
651 #define __GFP_IO 0x40 /* Can start low memory physical IO? */
652 #define __GFP_HIGHIO 0x80 /* Can start high mem physical IO? */
653 #define __GFP_FS 0x100 /* Can call down to low-level FS? */
654 
655 #define GFP_ATOMIC (__GFP_HIGH)
656 #define GFP_USER ( __GFP_WAIT | __GFP_IO | __GFP_HIGHIO | __GFP_FS)
657 #define GFP_HIGHUSER ( __GFP_WAIT | __GFP_IO | __GFP_HIGHIO | __GFP_FS | __GFP_HIGHMEM)
658 #define GFP_KERNEL (__GFP_HIGH | __GFP_WAIT | __GFP_IO | __GFP_HIGHIO | __GFP_FS)
659 #define GFP_NOFS 0
660 #define __GFP_NOFAIL 0
661 
662 
663 #define KM_USER0 0
664 
665 //
666 // buffer head definitions
667 //
668 
670  BH_Uptodate, /* Contains valid data */
671  BH_Dirty, /* Is dirty */
672  BH_Verified, /* Is verified */
673  BH_Lock, /* Is locked */
674  BH_Req, /* Has been submitted for I/O */
675  BH_Uptodate_Lock, /* Used by the first bh in a page, to serialise
676  * IO completion of other buffers in the page
677  */
678 
679  BH_Mapped, /* Has a disk mapping */
680  BH_New, /* Disk mapping was newly created by get_block */
681  BH_Async_Read, /* Is under end_buffer_async_read I/O */
682  BH_Async_Write, /* Is under end_buffer_async_write I/O */
683  BH_Delay, /* Buffer is not yet allocated on disk */
684  BH_Boundary, /* Block is followed by a discontiguity */
685  BH_Write_EIO, /* I/O error on write */
686  BH_Ordered, /* ordered write */
687  BH_Eopnotsupp, /* operation not supported (barrier) */
688  BH_Unwritten, /* Buffer is allocated on disk but not written */
689 
690  BH_PrivateStart, /* not a state bit, but the first bit available
691  * for private allocation by other entities
692  */
693 };
694 
695 #define PAGE_CACHE_SIZE (PAGE_SIZE)
696 #define PAGE_CACHE_SHIFT (12)
697 #define MAX_BUF_PER_PAGE (PAGE_CACHE_SIZE / 512)
698 
699 #ifdef __REACTOS__
700 struct buffer_head;
701 #endif
702 typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);
703 
704 /*
705  * Historically, a buffer_head was used to map a single block
706  * within a page, and of course as the unit of I/O through the
707  * filesystem and block layers. Nowadays the basic I/O unit
708  * is the bio, and buffer_heads are used for extracting block
709  * mappings (via a get_block_t call), for tracking state within
710  * a page (via a page_mapping) and for wrapping bio submission
711  * for backward compatibility reasons (e.g. submit_bh).
712  */
713 struct buffer_head {
714  LIST_ENTRY b_link; /* to be added to reaper list */
715  unsigned long b_state; /* buffer state bitmap (see above) */
716  struct page *b_page; /* the page this bh is mapped to */
717  PMDL b_mdl; /* MDL of the locked buffer */
718  void *b_bcb; /* BCB of the buffer */
719 
720  // kdev_t b_dev; /* device (B_FREE = free) */
721  struct block_device *b_bdev; /* block device object */
722 
723  blkcnt_t b_blocknr; /* start block number */
724  size_t b_size; /* size of mapping */
725  char * b_data; /* pointer to data within the page */
726  bh_end_io_t *b_end_io; /* I/O completion */
727  void *b_private; /* reserved for b_end_io */
728  // struct list_head b_assoc_buffers; /* associated with another mapping */
729  // struct address_space *b_assoc_map; /* mapping this buffer is associated with */
730  atomic_t b_count; /* users using this buffer_head */
731  struct rb_node b_rb_node; /* Red-black tree node entry */
732 
733  LARGE_INTEGER b_ts_creat; /* creation time*/
734  LARGE_INTEGER b_ts_drop; /* drop time (to be released) */
735 };
736 
737 
738 /*
739  * macro tricks to expand the set_buffer_foo(), clear_buffer_foo()
740  * and buffer_foo() functions.
741  */
742 #define BUFFER_FNS(bit, name) \
743 static inline void set_buffer_##name(struct buffer_head *bh) \
744 { \
745  set_bit(BH_##bit, &(bh)->b_state); \
746 } \
747 static inline void clear_buffer_##name(struct buffer_head *bh) \
748 { \
749  clear_bit(BH_##bit, &(bh)->b_state); \
750 } \
751 static inline int buffer_##name(const struct buffer_head *bh) \
752 { \
753  return test_bit(BH_##bit, &(bh)->b_state); \
754 }
755 
756 /*
757  * test_set_buffer_foo() and test_clear_buffer_foo()
758  */
759 #define TAS_BUFFER_FNS(bit, name) \
760 static inline int test_set_buffer_##name(struct buffer_head *bh) \
761 { \
762  return test_and_set_bit(BH_##bit, &(bh)->b_state); \
763 } \
764 static inline int test_clear_buffer_##name(struct buffer_head *bh) \
765 { \
766  return test_and_clear_bit(BH_##bit, &(bh)->b_state); \
767 } \
768 
769 /*
770  * Emit the buffer bitops functions. Note that there are also functions
771  * of the form "mark_buffer_foo()". These are higher-level functions which
772  * do something in addition to setting a b_state bit.
773  */
774 BUFFER_FNS(Uptodate, uptodate)
775 BUFFER_FNS(Dirty, dirty)
776 TAS_BUFFER_FNS(Dirty, dirty)
777 BUFFER_FNS(Verified, verified)
778 BUFFER_FNS(Lock, locked)
779 TAS_BUFFER_FNS(Lock, locked)
780 BUFFER_FNS(Req, req)
781 TAS_BUFFER_FNS(Req, req)
782 BUFFER_FNS(Mapped, mapped)
783 BUFFER_FNS(New, new)
784 BUFFER_FNS(Async_Read, async_read)
785 BUFFER_FNS(Async_Write, async_write)
786 BUFFER_FNS(Delay, delay)
787 BUFFER_FNS(Boundary, boundary)
788 BUFFER_FNS(Write_EIO, write_io_error)
789 BUFFER_FNS(Ordered, ordered)
790 BUFFER_FNS(Eopnotsupp, eopnotsupp)
791 BUFFER_FNS(Unwritten, unwritten)
792 
793 #define bh_offset(bh) ((unsigned long)(bh)->b_data & ~PAGE_MASK)
794 #define touch_buffer(bh) mark_page_accessed(bh->b_page)
795 
796 /* If we *know* page->private refers to buffer_heads */
797 
798 #define page_buffers(page) \
799  ( \
800  BUG_ON(!PagePrivate(page)), \
801  ((struct buffer_head *)page_private(page)) \
802  )
803 #define page_has_buffers(page) PagePrivate(page)
804 
805 
806 /*
807  * Declarations
808  */
809 
810 void mark_buffer_dirty(struct buffer_head *bh);
811 void init_buffer(struct buffer_head *, bh_end_io_t *, void *);
812 void set_bh_page(struct buffer_head *bh,
813  struct page *page, unsigned long offset);
814 int try_to_free_buffers(struct page *);
815 struct buffer_head *alloc_page_buffers(struct page *page, unsigned long size,
816  int retry);
817 void create_empty_buffers(struct page *, unsigned long,
818  unsigned long b_state);
819 
820 /* Things to do with buffers at mapping->private_list */
821 void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode);
822 int inode_has_buffers(struct inode *);
823 void invalidate_inode_buffers(struct inode *);
824 int remove_inode_buffers(struct inode *inode);
825 #ifndef __REACTOS__
826 int sync_mapping_buffers(struct address_space *mapping);
827 #endif
829 
830 void mark_buffer_async_write(struct buffer_head *bh);
831 void invalidate_bdev(struct block_device *);
832 int sync_blockdev(struct block_device *bdev);
833 void __wait_on_buffer(struct buffer_head *);
835 int fsync_bdev(struct block_device *);
836 struct super_block *freeze_bdev(struct block_device *);
837 void thaw_bdev(struct block_device *, struct super_block *);
838 int fsync_super(struct super_block *);
839 int fsync_no_super(struct block_device *);
841  unsigned long size);
842 struct buffer_head *get_block_bh(struct block_device *bdev, sector_t block,
843  unsigned long size, int zero);
844 struct buffer_head *__getblk(struct block_device *bdev, sector_t block,
845  unsigned long size);
846 void __brelse(struct buffer_head *);
847 void __bforget(struct buffer_head *);
848 void __breadahead(struct block_device *, sector_t block, unsigned int size);
849 struct buffer_head *__bread(struct block_device *, sector_t block, unsigned size);
850 void invalidate_bh_lrus(void);
851 struct buffer_head *alloc_buffer_head(gfp_t gfp_flags);
852 void free_buffer_head(struct buffer_head * bh);
853 void unlock_buffer(struct buffer_head *bh);
854 void __lock_buffer(struct buffer_head *bh);
855 void ll_rw_block(int, int, struct buffer_head * bh[]);
856 int sync_dirty_buffer(struct buffer_head *bh);
857 int submit_bh(int, struct buffer_head *);
858 void write_boundary_block(struct block_device *bdev,
859  sector_t bblock, unsigned blocksize);
860 int bh_uptodate_or_lock(struct buffer_head *bh);
861 int bh_submit_read(struct buffer_head *bh);
862 /* They are separately managed */
865 void extents_mark_buffer_dirty(struct buffer_head *bh);
866 void extents_brelse(struct buffer_head *bh);
867 void extents_bforget(struct buffer_head *bh);
868 void buffer_head_remove(struct block_device *bdev, struct buffer_head *bh);
869 
870 extern int buffer_heads_over_limit;
871 
872 /*
873  * Generic address_space_operations implementations for buffer_head-backed
874  * address_spaces.
875  */
876 
877 #if 0
878 
879 int block_write_full_page(struct page *page, get_block_t *get_block,
880  struct writeback_control *wbc);
881 int block_read_full_page(struct page*, get_block_t*);
882 int block_write_begin(struct file *, struct address_space *,
883  loff_t, unsigned, unsigned,
884  struct page **, void **, get_block_t*);
885 int block_write_end(struct file *, struct address_space *,
886  loff_t, unsigned, unsigned,
887  struct page *, void *);
888 int generic_write_end(struct file *, struct address_space *,
889  loff_t, unsigned, unsigned,
890  struct page *, void *);
891 
892 int block_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
893 int cont_write_begin(struct file *, struct address_space *, loff_t,
894  unsigned, unsigned, struct page **, void **,
895  get_block_t *, loff_t *);
896 int block_page_mkwrite(struct vm_area_struct *vma, struct page *page,
897  get_block_t get_block);
898 sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
899 int generic_commit_write(struct file *, struct page *, unsigned, unsigned);
900 int block_truncate_page(struct address_space *, loff_t, get_block_t *);
901 int file_fsync(struct file *, struct dentry *, int);
902 int nobh_write_begin(struct file *, struct address_space *,
903  loff_t, unsigned, unsigned,
904  struct page **, void **, get_block_t*);
905 int nobh_write_end(struct file *, struct address_space *,
906  loff_t, unsigned, unsigned,
907  struct page *, void *);
908 int nobh_truncate_page(struct address_space *, loff_t, get_block_t *);
909 int nobh_writepage(struct page *page, get_block_t *get_block,
910  struct writeback_control *wbc);
911 int generic_cont_expand_simple(struct inode *inode, loff_t size);
912 #endif
913 
914 void block_invalidatepage(struct page *page, unsigned long offset);
915 void page_zero_new_buffers(struct page *page, unsigned from, unsigned to);
916 int block_commit_write(struct page *page, unsigned from, unsigned to);
917 void block_sync_page(struct page *);
918 
919 void buffer_init(void);
920 
921 /*
922  * inline definitions
923  */
924 #if 0
925 static inline void attach_page_buffers(struct page *page,
926  struct buffer_head *head)
927 {
928  page_cache_get(page);
929  SetPagePrivate(page);
930  set_page_private(page, (unsigned long)head);
931 }
932 #endif
933 
934 static inline void get_bh(struct buffer_head *bh)
935 {
936  atomic_inc(&bh->b_count);
937 }
938 
939 static inline void put_bh(struct buffer_head *bh)
940 {
941  if (bh)
942  __brelse(bh);
943 }
944 
945 static inline void brelse(struct buffer_head *bh)
946 {
947  if (bh)
948  __brelse(bh);
949 }
950 
951 static inline void fini_bh(struct buffer_head **bh)
952 {
953  if (bh && *bh) {
954  brelse(*bh);
955  *bh = NULL;
956  }
957 }
958 
959 static inline void bforget(struct buffer_head *bh)
960 {
961  if (bh)
962  __bforget(bh);
963 }
964 
965 static inline struct buffer_head *
967 {
968  return get_block_bh(sb->s_bdev, block, sb->s_blocksize, 0);
969 }
970 
971 static inline struct buffer_head *
973 {
974  return get_block_bh(sb->s_bdev, block, sb->s_blocksize, 1);
975 }
976 
977 static inline struct buffer_head *
979 {
980  struct buffer_head *bh = __getblk(sb->s_bdev, block, sb->s_blocksize);
981  if (!bh)
982  return NULL;
983  if (!buffer_uptodate(bh) && (bh_submit_read(bh) < 0)) {
984  brelse(bh);
985  return NULL;
986  }
987  return bh;
988 }
989 
990 static inline struct buffer_head *
992 {
993  return __find_get_block(sb->s_bdev, block, sb->s_blocksize);
994 }
995 
996 static inline void
998 {
999  set_buffer_mapped(bh);
1000  bh->b_bdev = sb->s_bdev;
1001  bh->b_blocknr = block;
1002  bh->b_size = sb->s_blocksize;
1003 }
1004 
1005 /*
1006  * Calling wait_on_buffer() for a zero-ref buffer is illegal, so we call into
1007  * __wait_on_buffer() just to trip a debug check. Because debug code in inline
1008  * functions is bloaty.
1009  */
1010 
1011 static inline void wait_on_buffer(struct buffer_head *bh)
1012 {
1013  might_sleep();
1014  if (buffer_locked(bh) || atomic_read(&bh->b_count) == 0)
1015  __wait_on_buffer(bh);
1016 }
1017 
1018 static inline void lock_buffer(struct buffer_head *bh)
1019 {
1020  might_sleep();
1021  if (test_set_buffer_locked(bh))
1022  __lock_buffer(bh);
1023 }
1024 
1025 extern int __set_page_dirty_buffers(struct page *page);
1026 
1027 //
1028 // unicode character
1029 //
1030 
1031 struct nls_table {
1032  char *charset;
1033  char *alias;
1034  int (*uni2char) (wchar_t uni, unsigned char *out, int boundlen);
1035  int (*char2uni) (const unsigned char *rawstring, int boundlen,
1036  wchar_t *uni);
1037  unsigned char *charset2lower;
1038  unsigned char *charset2upper;
1039  struct module *owner;
1040  struct nls_table *next;
1041 };
1042 
1043 /* this value hold the maximum octet of charset */
1044 #define NLS_MAX_CHARSET_SIZE 6 /* for UTF-8 */
1045 
1046 /* nls.c */
1047 extern int register_nls(struct nls_table *);
1048 extern int unregister_nls(struct nls_table *);
1049 extern struct nls_table *load_nls(char *);
1050 extern void unload_nls(struct nls_table *);
1051 extern struct nls_table *load_nls_default(void);
1052 
1053 extern int utf8_mbtowc(wchar_t *, const __u8 *, int);
1054 extern int utf8_mbstowcs(wchar_t *, const __u8 *, int);
1055 extern int utf8_wctomb(__u8 *, wchar_t, int);
1056 extern int utf8_wcstombs(__u8 *, const wchar_t *, int);
1057 
1058 //
1059 // kernel jiffies
1060 //
1061 
1062 #define HZ (100)
1063 
1064 static inline __u32 JIFFIES()
1065 {
1066  LARGE_INTEGER Tick;
1067 
1068  KeQueryTickCount(&Tick);
1069  Tick.QuadPart *= KeQueryTimeIncrement();
1070  Tick.QuadPart /= (10000000 / HZ);
1071 
1072  return Tick.LowPart;
1073 }
1074 
1075 #define jiffies JIFFIES()
1076 
1077 //
1078 // memory routines
1079 //
1080 
1081 #ifdef _WIN2K_TARGET_
1082 
1083 typedef GUID UUID;
1085 NTSTATUS
1086 ExUuidCreate(
1087  OUT UUID *Uuid
1088 );
1089 
1091 PVOID
1092 NTAPI
1096  IN ULONG Tag
1097 );
1098 
1099 #define ExFreePoolWithTag(_P, _T) ExFreePool(_P)
1100 #endif
1101 
1105  IN ULONG Tag
1106 );
1107 
1108 VOID
1109 Ext2FreePool(
1110  IN PVOID P,
1111  IN ULONG Tag
1112 );
1113 
1114 void *kzalloc(int size, int flags);
1115 #define kmalloc(size, gfp) Ext2AllocatePool(NonPagedPool, size, 'JBDM')
1116 #define kfree(p) Ext2FreePool(p, 'JBDM')
1117 
1118 
1119 /* memory slab */
1120 
1121 #define SLAB_HWCACHE_ALIGN 0x00002000U /* align objs on a h/w cache lines */
1122 #define SLAB_KERNEL 0x00000001U
1123 #define SLAB_TEMPORARY 0x00000002U
1124 
1125 typedef void (*kmem_cache_cb_t)(void*, kmem_cache_t *, unsigned long);
1126 
1127 struct kmem_cache {
1128  CHAR name[32];
1135 };
1136 
1137 
1138 kmem_cache_t *
1140  const char *name,
1141  size_t size,
1142  size_t offset,
1143  unsigned long flags,
1145 );
1146 
1147 void* kmem_cache_alloc(kmem_cache_t *kc, int flags);
1148 void kmem_cache_free(kmem_cache_t *kc, void *p);
1150 
1151 
1152 //
1153 // block device
1154 //
1155 
1156 #define BDEVNAME_SIZE 32 /* Largest string for a blockdev identifier */
1157 
1158 //
1159 // ll_rw_block ....
1160 //
1161 
1162 
1163 #define RW_MASK 1
1164 #define RWA_MASK 2
1165 #define READ 0
1166 #define WRITE 1
1167 #define READA 2 /* read-ahead - don't block if no resources */
1168 #define SWRITE 3 /* for ll_rw_block() - wait for buffer lock */
1169 #define READ_SYNC (READ | (1 << BIO_RW_SYNC))
1170 #define READ_META (READ | (1 << BIO_RW_META))
1171 #define WRITE_SYNC (WRITE | (1 << BIO_RW_SYNC))
1172 #define WRITE_BARRIER ((1 << BIO_RW) | (1 << BIO_RW_BARRIER))
1173 
1174 //
1175 // timer routines
1176 //
1177 
1178 /*
1179  * These inlines deal with timer wrapping correctly. You are
1180  * strongly encouraged to use them
1181  * 1. Because people otherwise forget
1182  * 2. Because if the timer wrap changes in future you won't have to
1183  * alter your driver code.
1184  *
1185  * time_after(a,b) returns true if the time a is after time b.
1186  *
1187  * Do this with "<0" and ">=0" to only test the sign of the result. A
1188  * good compiler would generate better code (and a really good compiler
1189  * wouldn't care). Gcc is currently neither.
1190  */
1191 #define typecheck(x, y) (TRUE)
1192 
1193 #define time_after(a,b) \
1194  (typecheck(unsigned long, a) && \
1195  typecheck(unsigned long, b) && \
1196  ((long)(b) - (long)(a) < 0))
1197 #define time_before(a,b) time_after(b,a)
1198 
1199 #define time_after_eq(a,b) \
1200  (typecheck(unsigned long, a) && \
1201  typecheck(unsigned long, b) && \
1202  ((long)(a) - (long)(b) >= 0))
1203 #define time_before_eq(a,b) time_after_eq(b,a)
1204 
1205 #define time_in_range(a,b,c) \
1206  (time_after_eq(a,b) && \
1207  time_before_eq(a,c))
1208 
1209 #define smp_rmb() do {}while(0)
1210 
1211 
1212 static inline __u32 do_div64 (__u64 * n, __u64 b)
1213 {
1214  __u64 mod;
1215 
1216  mod = *n % b;
1217  *n = *n / b;
1218  return (__u32) mod;
1219 }
1220 #define do_div(n, b) do_div64(&(n), (__u64)b)
1221 
1222 #endif // _EXT2_MODULE_HEADER_
void __bforget(struct buffer_head *)
Definition: linux.c:835
atomic_t count
Definition: module.h:570
struct module * owner
Definition: module.h:1039
static unsigned int block
Definition: xmlmemory.c:118
static DWORD async_read(http_request_t *req, void *buf, DWORD size, DWORD read_pos, DWORD *ret_read)
Definition: http.c:3167
static void le16_add_cpu(__le16 *var, u16 val)
Definition: module.h:184
__u32 index
Definition: module.h:571
DISK_GEOMETRY bd_geo
Definition: module.h:542
unsigned __bitwise gfp_t
Definition: types.h:69
kmem_cache_t * kmem_cache_create(const char *name, size_t size, size_t offset, unsigned long flags, kmem_cache_cb_t ctor)
Definition: linux.c:48
int unregister_nls(struct nls_table *)
Definition: nls_base.c:185
unsigned char __u8
Definition: compat.h:88
static void get_bh(struct buffer_head *bh)
Definition: module.h:934
int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key)
int inode_has_buffers(struct inode *)
#define IN
Definition: typedefs.h:38
int fsync_bdev(struct block_device *)
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
ULONGLONG FASTCALL RtlUlonglongByteSwap(IN ULONGLONG Source)
Definition: byteswap.c:86
void unmap_underlying_metadata(struct block_device *bdev, sector_t block)
#define InterlockedAnd
Definition: interlocked.h:62
void * addr
Definition: module.h:567
struct LOOKASIDE_ALIGN _NPAGED_LOOKASIDE_LIST NPAGED_LOOKASIDE_LIST
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
PVOID wait_queue_t
Definition: module.h:460
void set_bh_page(struct buffer_head *bh, struct page *page, unsigned long offset)
PFILE_OBJECT bd_volume
Definition: module.h:546
rwlock_t lock
Definition: tcpcore.h:1163
void unlock_buffer(struct buffer_head *bh)
Definition: linux.c:845
unsigned __int64 sector_t
Definition: types.h:78
int submit_bh(int, struct buffer_head *)
Definition: linux.c:784
static int need_resched()
Definition: module.h:435
#define error(str)
Definition: mkdosfs.c:1605
#define __cdecl
Definition: accygwin.h:79
unsigned long expires
Definition: module.h:521
NTKERNELAPI PVOID NTAPI ExAllocatePoolWithTag(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN ULONG Tag)
Definition: heap.c:552
ULONG nr
Definition: thread.c:7
void prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state)
Definition: linux.c:231
void __free_pages(struct page *page, unsigned int order)
KIRQL irql
Definition: module.h:300
struct buffer_head * get_block_bh(struct block_device *bdev, sector_t block, unsigned long size, int zero)
Definition: linux.c:774
struct outqueuenode * head
Definition: adnsresfilter.c:66
static void fini_bh(struct buffer_head **bh)
Definition: module.h:951
#define BITS_PER_LONG
Definition: types.h:82
void * journal_info
Definition: module.h:422
atomic_t b_count
Definition: module.h:730
superblock * sb
Definition: btrfs.c:4137
static struct buffer_head * sb_getblk(struct super_block *sb, sector_t block)
Definition: module.h:966
void __lock_buffer(struct buffer_head *bh)
Definition: linux.c:841
void free_buffer_head(struct buffer_head *bh)
Definition: linux.c:346
struct nls_table * next
Definition: module.h:1040
Definition: fs.h:64
unsigned long data
Definition: module.h:524
char CHAR
Definition: xmlstorage.h:175
ULONG flags
Definition: module.h:1129
void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode)
unsigned char * charset2lower
Definition: module.h:1037
atomic_t count
Definition: module.h:1131
bh_end_io_t * b_end_io
Definition: module.h:726
static void put_bh(struct buffer_head *bh)
Definition: module.h:939
ULONG FASTCALL RtlUlongByteSwap(IN ULONG Source)
Definition: byteswap.c:61
#define le16_to_cpu
Definition: module.h:149
LONG NTSTATUS
Definition: precomp.h:26
LIST_ENTRY b_link
Definition: module.h:714
GLintptr offset
Definition: glext.h:5920
ULONG NTAPI KeQueryTimeIncrement(VOID)
Definition: clock.c:153
static int cond_resched()
Definition: module.h:432
GLdouble n
Definition: glext.h:7729
#define New(t)
Definition: rtf.h:1086
void mark_buffer_async_write(struct buffer_head *bh)
long long_ptr_t
Definition: types.h:91
void * kmem_cache_alloc(kmem_cache_t *kc, int flags)
Definition: linux.c:92
char * charset
Definition: module.h:1032
DWORD pid_t
Definition: types.h:91
size_t b_size
Definition: module.h:724
void * b_private
Definition: module.h:727
void * bd_priv
Definition: module.h:544
PDEVICE_OBJECT bd_dev
Definition: module.h:540
static void bforget(struct buffer_head *bh)
Definition: module.h:959
#define atomic_read(v)
Definition: atomic.h:23
struct _spinlock_t spinlock_t
void truncate_inode_pages(struct address_space *, loff_t)
atomic_t acount
Definition: module.h:1132
NPAGED_LOOKASIDE_LIST la
Definition: module.h:1133
void ll_rw_block(int, int, struct buffer_head *bh[])
Definition: linux.c:854
#define IS_ERR_VALUE(x)
Definition: module.h:235
void unload_nls(struct nls_table *)
Definition: nls_base.c:240
LPFNCONSTRUCTOR ctor
Definition: msctf.c:83
#define FASTCALL
Definition: nt_native.h:50
struct rb_root bd_bh_root
Definition: module.h:551
GUID UUID
Definition: module.h:1083
ULONG32 u32
Definition: btrfs.h:14
void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state)
Definition: linux.c:212
struct buffer_head * __getblk(struct block_device *bdev, sector_t block, unsigned long size)
Definition: linux.c:791
static int clear_bit(int nr, volatile unsigned long *addr)
Definition: module.h:357
static __u32 do_div64(__u64 *n, __u64 b)
Definition: module.h:1212
struct list_head task_list
Definition: module.h:469
void invalidate_bh_lrus(void)
static void le64_add_cpu(__le64 *var, u64 val)
Definition: module.h:194
static void brelse(struct buffer_head *bh)
Definition: module.h:945
_Check_return_ unsigned short __cdecl _byteswap_ushort(_In_ unsigned short)
Definition: fs.h:78
Definition: list.h:15
spinlock_t lock
Definition: module.h:489
UCHAR KIRQL
Definition: env_spec_w32.h:591
void() bh_end_io_t(struct buffer_head *bh, int uptodate)
Definition: module.h:702
struct nls_table * load_nls_default(void)
PMDL b_mdl
Definition: module.h:717
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
kmem_cache_cb_t constructor
Definition: module.h:1134
struct list_head entry
Definition: module.h:520
KEVENT bd_bh_notify
Definition: module.h:553
struct rb_node b_rb_node
Definition: module.h:731
struct list_head task_list
Definition: module.h:490
void wait_queue_destroy(struct __wait_queue *)
Definition: linux.c:142
LARGE_MCB bd_extents
Definition: module.h:547
unsigned __int64 blkcnt_t
Definition: types.h:79
__u32 flags
Definition: module.h:572
unsigned long bd_flags
Definition: module.h:538
static PVOID ptr
Definition: dispmode.c:27
int wake_up(wait_queue_head_t *queue)
Definition: linux.c:279
static void wait_on_buffer(struct buffer_head *bh)
Definition: module.h:1011
struct super_block * freeze_bdev(struct block_device *)
void * mapping
Definition: module.h:568
int(* uni2char)(wchar_t uni, unsigned char *out, int boundlen)
Definition: module.h:1034
static void * ERR_PTR(long error)
Definition: module.h:237
#define le32_to_cpu
Definition: module.h:147
struct buffer_head * __bread(struct block_device *, sector_t block, unsigned size)
void extents_brelse(struct buffer_head *bh)
Definition: ext4_bh.c:51
Definition: _queue.h:59
Definition: module.h:674
#define __le16
Definition: types.h:39
int sync_dirty_buffer(struct buffer_head *bh)
Definition: linux.c:890
int utf8_wcstombs(__u8 *, const wchar_t *, int)
Definition: nls_base.c:136
smooth NULL
Definition: ftsmooth.c:416
pid_t pid
Definition: module.h:419
unsigned long b_state
Definition: module.h:715
void extents_mark_buffer_dirty(struct buffer_head *bh)
Definition: ext4_bh.c:39
struct block_device * b_bdev
Definition: module.h:721
#define NTKERNELAPI
Definition: module.h:566
void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
Definition: linux.c:250
#define might_sleep()
Definition: module.h:440
NTKERNELAPI NTSTATUS ExUuidCreate(OUT UUID *Uuid)
Definition: uuid.c:385
_Check_return_ unsigned long __cdecl _byteswap_ulong(_In_ unsigned long)
Definition: fs.h:117
KSPIN_LOCK lock
Definition: module.h:299
static int test_bit(int nr, volatile const unsigned long *addr)
Definition: module.h:381
static __u32 JIFFIES()
Definition: module.h:1064
VOID NTAPI KeQueryTickCount(IN PLARGE_INTEGER TickCount)
Definition: clock.c:165
#define b
Definition: ke_i.h:79
static int test_and_clear_bit(int nr, volatile unsigned long *addr)
Definition: module.h:373
GLuint GLfloat * val
Definition: glext.h:7180
LIST_ENTRY bd_bh_free
Definition: module.h:552
struct page * b_page
Definition: module.h:716
FAST_MUTEX
Definition: extypes.h:17
static long IS_ERR(const void *ptr)
Definition: module.h:247
kmem_cache_t * bd_bh_cache
Definition: module.h:549
static void atomic_inc(atomic_t volatile *v)
Definition: atomic.h:95
void * b_bcb
Definition: module.h:718
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
int try_to_free_buffers(struct page *)
GLsizeiptr size
Definition: glext.h:5919
struct buffer_head * alloc_buffer_head(gfp_t gfp_flags)
static struct buffer_head * sb_getblk_zero(struct super_block *sb, sector_t block)
Definition: module.h:972
void invalidate_bdev(struct block_device *)
INT POOL_TYPE
Definition: typedefs.h:76
uint64_t ULONGLONG
Definition: typedefs.h:65
static long PTR_ERR(const void *ptr)
Definition: module.h:242
void(* kmem_cache_cb_t)(void *, kmem_cache_t *, unsigned long)
Definition: module.h:1125
struct buffer_head * alloc_page_buffers(struct page *page, unsigned long size, int retry)
static FILE * out
Definition: regtests2xml.c:44
#define BUFFER_FNS(bit, name)
Definition: module.h:742
GLenum GLenum GLenum GLenum mapping
Definition: glext.h:9031
blkcnt_t b_blocknr
Definition: module.h:723
wait_queue_head_t * bh_waitq_head(struct buffer_head *bh)
atomic_t bd_count
Definition: module.h:539
unsigned int __u32
Definition: compat.h:90
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
void create_empty_buffers(struct page *, unsigned long, unsigned long b_state)
LARGE_INTEGER b_ts_drop
Definition: module.h:734
* PFILE_OBJECT
Definition: iotypes.h:1955
GLbitfield flags
Definition: glext.h:7161
int __set_page_dirty_buffers(struct page *page)
int bh_uptodate_or_lock(struct buffer_head *bh)
static struct buffer_head * sb_find_get_block(struct super_block *sb, sector_t block)
Definition: module.h:991
unsigned __int64 loff_t
Definition: types.h:80
void __brelse(struct buffer_head *)
Definition: linux.c:800
unsigned long __get_free_pages(unsigned int gfp_mask, unsigned int order)
static struct buffer_head * sb_bread(struct super_block *sb, sector_t block)
Definition: module.h:978
void sync()
Definition: prep.c:9
static double zero
Definition: j0_y0.c:96
ULONG64 u64
Definition: btrfs.h:15
void block_invalidatepage(struct page *page, unsigned long offset)
GLenum const GLvoid * addr
Definition: glext.h:9621
#define le64_to_cpu
Definition: module.h:145
void delay(unsigned msec)
Definition: i386rtl.c:32
int remove_inode_buffers(struct inode *inode)
void kmem_cache_free(kmem_cache_t *kc, void *p)
Definition: linux.c:103
int buffer_heads_over_limit
static int state
Definition: maze.c:121
ULONG LowPart
Definition: typedefs.h:104
int register_nls(struct nls_table *)
Definition: nls_base.c:162
#define InterlockedOr
Definition: interlocked.h:224
void init_buffer(struct buffer_head *, bh_end_io_t *, void *)
Definition: typedefs.h:117
IN OUT PLONG IN OUT PLONG Addend IN OUT PLONG IN LONG IN OUT PLONG IN LONG Increment IN PNDIS_RW_LOCK Lock
Definition: CrNtStubs.h:75
char comm[32]
Definition: module.h:421
#define HZ
Definition: module.h:1062
PVOID Ext2AllocatePool(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN ULONG Tag)
Definition: debug.c:2684
int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key)
int bh_submit_read(struct buffer_head *bh)
Definition: linux.c:884
void mark_buffer_dirty(struct buffer_head *bh)
Definition: linux.c:906
GLenum mode
Definition: glext.h:6217
#define P(row, col)
char * b_data
Definition: module.h:725
struct page mem_map_t
int sync_mapping_buffers(struct address_space *mapping)
struct buffer_head * __find_get_block(struct block_device *bdev, sector_t block, unsigned long size)
Definition: linux.c:924
ULONG_PTR SIZE_T
Definition: typedefs.h:78
FAST_MUTEX lock
Definition: module.h:447
int kmem_cache_destroy(kmem_cache_t *kc)
Definition: linux.c:82
void block_sync_page(struct page *)
void buffer_init(void)
static void map_bh(struct buffer_head *bh, struct super_block *sb, sector_t block)
Definition: module.h:997
char * alias
Definition: module.h:1033
void thaw_bdev(struct block_device *, struct super_block *)
static int test_and_set_bit(int nr, volatile unsigned long *addr)
Definition: module.h:395
void buffer_head_remove(struct block_device *bdev, struct buffer_head *bh)
Definition: linux.c:424
_Check_return_ unsigned __int64 __cdecl _byteswap_uint64(_In_ unsigned __int64)
#define __le64
Definition: types.h:41
unsigned short USHORT
Definition: pedump.c:61
ULONG size
Definition: module.h:1130
static int set_bit(int nr, volatile unsigned long *addr)
Definition: module.h:338
static void lock_buffer(struct buffer_head *bh)
Definition: module.h:1018
ANSI_STRING bd_name
Definition: module.h:541
int utf8_mbtowc(wchar_t *, const __u8 *, int)
Definition: nls_base.c:49
#define long
Definition: qsort.c:33
KEVENT event
Definition: module.h:468
int fsync_super(struct super_block *)
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
int fsync_no_super(struct block_device *)
u64 __u64
Definition: btrfs.h:20
void invalidate_inode_buffers(struct inode *)
#define ORDER_PER_LONG
Definition: types.h:83
void write_boundary_block(struct block_device *bdev, sector_t bblock, unsigned blocksize)
VOID Ext2FreePool(IN PVOID P, IN ULONG Tag)
Definition: debug.c:2697
IN ULONG IN ULONG Tag
Definition: evtlib.h:159
LARGE_INTEGER b_ts_creat
Definition: module.h:733
ERESOURCE bd_bh_lock
Definition: module.h:550
Definition: name.c:38
r dirty
Definition: btrfs.c:2863
void free_pages(unsigned long addr, unsigned int order)
void __wait_on_buffer(struct buffer_head *)
Definition: linux.c:850
#define OUT
Definition: typedefs.h:39
int sync_blockdev(struct block_device *bdev)
Definition: linux.c:911
struct __wait_queue * wait_queue_create()
Definition: linux.c:122
unsigned char * charset2upper
Definition: module.h:1038
int(* char2uni)(const unsigned char *rawstring, int boundlen, wchar_t *uni)
Definition: module.h:1035
USHORT FASTCALL RtlUshortByteSwap(IN USHORT Source)
Definition: byteswap.c:37
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS _Inout_ PLARGE_INTEGER NumberOfBytes
Definition: iotypes.h:998
static int spin_needbreak(spinlock_t *lock)
Definition: module.h:316
void __breadahead(struct block_device *, sector_t block, unsigned int size)
ULONG ERESOURCE
Definition: env_spec_w32.h:594
unsigned int ULONG
Definition: retypes.h:1
static void le32_add_cpu(__le32 *var, u32 val)
Definition: module.h:189
Definition: rbtree.h:97
Definition: module.h:680
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3167
bh_state_bits
Definition: module.h:669
#define cpu_to_le64
Definition: module.h:144
#define TAS_BUFFER_FNS(bit, name)
Definition: module.h:759
PARTITION_INFORMATION bd_part
Definition: module.h:543
struct buffer_head * extents_bread(struct super_block *sb, sector_t block)
Definition: ext4_bh.c:15
GLfloat GLfloat p
Definition: glext.h:8902
CardRegion * from
Definition: spigame.cpp:19
Definition: module.h:446
#define cpu_to_le16
Definition: module.h:148
USHORT u16
Definition: btrfs.h:13
unsigned int flags
Definition: module.h:466
_Must_inspect_result_ _In_ FLT_CONTEXT_TYPE _In_ SIZE_T _In_ POOL_TYPE PoolType
Definition: fltkernel.h:1444
struct nls_table * load_nls(char *)
Definition: nls_base.c:218
pid_t tid
Definition: module.h:420
int utf8_mbstowcs(wchar_t *, const __u8 *, int)
Definition: nls_base.c:79
int utf8_wctomb(__u8 *, wchar_t, int)
Definition: nls_base.c:108
#define cpu_to_le32
Definition: module.h:146
void * kzalloc(int size, int flags)
Definition: linux.c:34
int block_commit_write(struct page *page, unsigned from, unsigned to)
#define __int64
Definition: basetyps.h:16
void init_waitqueue_head(wait_queue_head_t *q)
Definition: linux.c:115
struct task_struct * current
Definition: linux.c:32
struct buffer_head * extents_bwrite(struct super_block *sb, sector_t block)
Definition: ext4_bh.c:27
LONGLONG QuadPart
Definition: typedefs.h:112
struct mutex mutex_t
Definition: path.c:41
#define __le32
Definition: types.h:40
static int mod
Definition: i386-dis.c:1273
void extents_bforget(struct buffer_head *bh)
Definition: ext4_bh.c:64
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
Definition: fci.c:126
void page_zero_new_buffers(struct page *page, unsigned from, unsigned to)