searchcode | source code search engine

36 : FELighting(filter, SpecularLighting, lightingColor, surfaceScale, 0, specularConstant, specularExponent, kernelUnitLengthX, kernelUnitLengthY, lightSource)

37 {

38 }

40 PassRefPtr<FESpecularLighting> FESpecularLighting::create(Filter* filter, const Color& lightingColor,

41 float surfaceScale, float specularConstant, float specularExponent,

42 float kernelUnitLengthX, float kernelUnitLengthY, PassRefPtr<LightSource> lightSource)

43 {

44 return adoptRef(new FESpecularLighting(filter, lightingColor, surfaceScale, specularConstant, specularExponent,

107 }

108

109 bool FESpecularLighting::setKernelUnitLengthX(float kernelUnitLengthX)

110 {

111 if (m_kernelUnitLengthX == kernelUnitLengthX)

112 return false;

113 m_kernelUnitLengthX = kernelUnitLengthX;

114 return true;

115 }

packet_history.c (http://omnia2droid.googlecode.com/svn/trunk/) C · 490 lines ✨ Summary

This C code implements a timestamp-based congestion control algorithm for TCP-like protocols, specifically DCCP (Datagram Congestion Control Protocol). It manages a ring buffer to store timestamp and CCVal values, sampling RTT (Round-Trip Time) from these values to adjust congestion control parameters. The code provides functions for allocating and purging the ring buffer, as well as computing RTT samples based on timestamp and CCVal values.

462 * it, but the cause does not seem to be here.

463 */

464 DCCP_BUG("please report to dccp@vger.kernel.org"

465 " => prev = %u, last = %u",

466 tfrc_rx_hist_rtt_prev_s(h)->tfrchrx_ccval,

inotify_fsnotify.c (http://omnia2droid.googlecode.com/svn/trunk/) C · 169 lines ✨ Summary

This C code implements inotify support for userspace, allowing user applications to receive notifications about file system events such as creation, modification, and deletion. It manages a data structure that tracks these events and notifies registered handlers when an event occurs. The code provides functions for handling events, freeing resources, and managing the underlying data structures.

53 wd = ientry->wd;

54

55 event_priv = kmem_cache_alloc(event_priv_cachep, GFP_KERNEL);

56 if (unlikely(!event_priv))

57 return -ENOMEM;

twofish.c (http://omnia2droid.googlecode.com/svn/trunk/) C · 215 lines ✨ Summary

This C code implements a Twofish cipher algorithm for encryption and decryption of blocks of data. It provides a generic driver for the Twofish algorithm, which can be used in various cryptographic applications. The code defines a struct `twofish_ctx` to hold the algorithm’s state, and functions `twofish_encrypt` and `twofish_decrypt` to perform the encryption and decryption operations, respectively.

6 * 256-bit key length added March 20, 1999

7 * Some modifications to reduce the text size by Werner Koch, April, 1998

8 * Ported to the kerneli patch by Marc Mutz <Marc@Mutz.com>

9 * Ported to CryptoAPI by Colin Slater <hoho@tacomeat.net>

10 *

types.h (http://omnia2droid.googlecode.com/svn/trunk/) C++ Header · 210 lines ✨ Summary

This C header file defines various data types used in Linux kernel programming, including integer and pointer types, bit manipulation types, and file system-related types. It provides a set of standardized types that can be used by both kernel code and user-space applications to ensure compatibility and avoid type collisions. The definitions are tailored for the Linux operating system and its specific architecture.

5

6 #ifndef __ASSEMBLY__

7 #ifdef __KERNEL__

8

9 #define DECLARE_BITMAP(name,bits) \

14 #include <linux/posix_types.h>

15

16 #ifdef __KERNEL__

17

18 typedef __u32 __kernel_dev_t;

19

20 typedef __kernel_fd_set fd_set;

21 typedef __kernel_dev_t dev_t;

22 typedef __kernel_ino_t ino_t;

23 typedef __kernel_mode_t mode_t;

if_tunnel.h (http://omnia2droid.googlecode.com/svn/trunk/) C++ Header · 73 lines ✨ Summary

This C header file defines a set of constants, structures, and macros for IP tunneling, specifically GRE (Generic Routing Encapsulation) tunnels. It provides definitions for tunnel parameters, flags, and protocol-related values, as well as functions to manage these tunnels. The code is likely used in Linux kernel development or network programming applications.

4 #include <linux/types.h>

5

6 #ifdef __KERNEL__

7 #include <linux/ip.h>

8 #endif

firewire.h (http://omnia2droid.googlecode.com/svn/trunk/) C++ Header · 433 lines ✨ Summary

This is a Linux kernel header file that provides an interface for interacting with FireWire (IEEE 1394) devices. It defines data structures and functions for sending and receiving packets, managing transactions, and handling ISO packet formats. The code allows users to access and control FireWire devices from the operating system.

5 #include <linux/device.h>

6 #include <linux/dma-mapping.h>

7 #include <linux/kernel.h>

8 #include <linux/kref.h>

9 #include <linux/list.h>

390 * An iso buffer is just a set of pages mapped for DMA in the

391 * specified direction. Since the pages are to be used for DMA, they

392 * are not mapped into the kernel virtual address space. We store the

393 * DMA address in the page private. The helper function

394 * fw_iso_buffer_map() will map the pages into a given vma.

mutex.h (http://omnia2droid.googlecode.com/svn/trunk/) C++ Header · 156 lines ✨ Summary

This C header file defines a mutex (mutual exclusion) lock data structure and associated functions for synchronization in Linux kernel programming. It provides basic locking mechanisms, including initialization, locking, unlocking, and waiting, as well as debugging features for tracking locks and detecting potential issues. The code is designed to be used by the Linux kernel and other applications that require thread-level synchronization.

65 /*

66 * This is the control structure for tasks blocked on mutex,

67 * which resides on the blocked task's kernel stack:

68 */

69 struct mutex_waiter {

120

121 /*

122 * See kernel/mutex.c for detailed documentation of these APIs.

123 * Also see Documentation/mutex-design.txt.

124 */

opl3.c (http://omnia2droid.googlecode.com/svn/trunk/) C · 1251 lines ✨ Summary

This C code implements a driver for Yamaha OPL3 and OPL4 FM synthesizers, specifically the YM3812 chip used in older Yamaha consoles. It provides an interface to control the synthesizer’s parameters and registers, allowing users to load and manipulate audio data. The code is part of the Linux kernel and can be loaded as a module or compiled into the kernel itself.

165 }

166

167 devc = kzalloc(sizeof(*devc), GFP_KERNEL);

168

169 if (devc == NULL)

mixer_oss.c (http://omnia2droid.googlecode.com/svn/trunk/) C · 1402 lines ✨ Summary

This C code implements a Linux kernel module for the ALSA (Advanced Linux Sound Architecture) sound system, specifically for OSS (Open Sound System) devices. It registers and manages OSS mixer devices, allowing users to interact with them through ioctl calls. The module initializes and exits when loaded/unloaded, and provides a way to notify handlers of changes to the mixer devices.

53 if (err < 0)

54 return err;

55 fmixer = kzalloc(sizeof(*fmixer), GFP_KERNEL);

56 if (fmixer == NULL) {

57 snd_card_file_remove(card, file);

515 return;

516 }

517 uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);

518 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);

553 return;

554 }

555 uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);

556 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);

616 if ((kctl = snd_ctl_find_numid(card, numid)) == NULL)

617 return;

618 uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL);

619 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);

kernel-docs.txt (http://photon-android.googlecode.com/svn/) Plain Text · 762 lines

304 * Title: "The Kernel Hacking HOWTO"

305 Author: Various Talented People, and Rusty.

306 Location: in kernel tree, Documentation/DocBook/kernel-hacking/

307 (must be built as "make {htmldocs | psdocs | pdfdocs})

308 Keywords: HOWTO, kernel contexts, deadlock, locking, modules,

324 Keywords: ALSA, sound, soundcard, driver, lowlevel, hardware.

325 Description: Advanced Linux Sound Architecture for developers,

326 both at kernel and user-level sides. ALSA is the Linux kernel

327 sound architecture in the 2.6 kernel version.

355 * Title: "Linux Kernel Locking HOWTO"

356 Author: Various Talented People, and Rusty.

357 Location: in kernel tree, Documentation/DocBook/kernel-locking/

358 (must be built as "make {htmldocs | psdocs | pdfdocs})

359 Keywords: locks, locking, spinlock, semaphore, atomic, race

685 URL: http://kt.zork.net/kernel-traffic/

686 Keywords: linux-kernel mailing list, weekly kernel news.

687 Description: Weekly newsletter covering the most relevant

688 discussions of the linux-kernel mailing list.

entry.S (http://omnia2droid.googlecode.com/svn/trunk/) Assembly · 1116 lines ✨ Summary

This Assembly code is part of a Linux kernel implementation, specifically the system call handling mechanism. It defines a table of system calls and their corresponding handlers, which are executed when a system call is made by user space. The code also includes constants for integer and symbol values used in the system call handling process.

231 st %r3,__LC_THREAD_INFO

232 ahi %r3,STACK_SIZE

233 st %r3,__LC_KERNEL_STACK # __LC_KERNEL_STACK = new kernel stack

234 br %r14

235

432

433 #

434 # kernel_execve function needs to deal with pt_regs that is not

435 # at the usual place

436 #

437 .globl kernel_execve

438 kernel_execve:

439 stm %r12,%r15,48(%r15)

440 lr %r14,%r15

807 tm SP_PSW+1(%r15),0x01 # returning to user ?

808 bno BASED(mcck_return)

809 l %r1,__LC_KERNEL_STACK # switch to kernel stack

810 s %r1,BASED(.Lc_spsize)

811 mvc SP_PTREGS(__PT_SIZE,%r1),SP_PTREGS(%r15)

traps.c (http://omnia2droid.googlecode.com/svn/trunk/) C · 768 lines ✨ Summary

This C code defines a set of exception handlers for a Linux kernel, which are triggered when specific conditions occur during execution. The handlers catch and handle exceptions such as stack overflows, division by zero, and data corruption, among others. They print error messages, trigger system calls, and perform other necessary actions to prevent the program from crashing or causing further damage.

1 /*

2 * arch/s390/kernel/traps.c

3 *

4 * S390 version

7 * Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),

8 *

9 * Derived from "arch/i386/kernel/traps.c"

11 */

16 */

17 #include <linux/sched.h>

18 #include <linux/kernel.h>

19 #include <linux/string.h>

20 #include <linux/errno.h>

73 /*

74 * For show_trace we have tree different stack to consider:

75 * - the panic stack which is used if the kernel stack has overflown

76 * - the asynchronous interrupt stack (cpu related)

77 * - the synchronous kernel stack (process related)

tsx09-common.c (http://omnia2droid.googlecode.com/svn/trunk/) C · 135 lines ✨ Summary

This C code is part of a Linux driver for QNAP TS-x09 boards, specifically handling power-off and Ethernet configuration. It defines functions to trigger power-off via UART1-attached PIC and parse MAC addresses from flash memory. The code also initializes the Ethernet platform data structure with the PHY address and provides functions to check and extract MAC addresses from a file in the flash partition.

11 */

12

13 #include <linux/kernel.h>

14 #include <linux/pci.h>

15 #include <linux/mv643xx_eth.h>

pwm-clock.c (http://omnia2droid.googlecode.com/svn/trunk/) C · 436 lines ✨ Summary

This C code initializes and configures PWM (Pulse Width Modulation) clocks for a SoC (System-on-Chip). It sets up parent-child relationships between clocks, registers PWM scaler, tclk, and tdiv clocks, and tin clocks with the SoC’s clock tree. The code is part of an arch_initcall function, indicating it’s executed early in the boot process to ensure proper clock configuration for the system.

12 #include <linux/init.h>

13 #include <linux/module.h>

14 #include <linux/kernel.h>

15 #include <linux/list.h>

16 #include <linux/errno.h>

wpactl.c (http://omnia2droid.googlecode.com/svn/trunk/) C · 992 lines ✨ Summary

This C code implements a Wi-Fi driver for Linux, specifically for WPA (Wi-Fi Protected Access) supplicant devices. It handles various commands to interact with the wireless network interface, such as setting up WPA parameters, scanning for nearby networks, and associating with a specific network. The code uses kernel-mode functions and data structures to manage the Wi-Fi connection.

200 */

201

202 int wpa_set_keys(PSDevice pDevice, void *ctx, BOOL fcpfkernel)

203 {

204 struct viawget_wpa_param *param=ctx;

231

232 //spin_unlock_irq(&pDevice->lock);

233 if(param->u.wpa_key.key && fcpfkernel) {

234 memcpy(&abyKey[0], param->u.wpa_key.key, param->u.wpa_key.key_len);

235 }

272

273 //spin_unlock_irq(&pDevice->lock);

274 if(param->u.wpa_key.seq && fcpfkernel) {

275 memcpy(&abySeq[0], param->u.wpa_key.seq, param->u.wpa_key.seq_len);

276 }

mmzone.h (http://omnia2droid.googlecode.com/svn/trunk/) C++ Header · 51 lines ✨ Summary

This C header file defines platform-specific memory management functions for the SH architecture, specifically for handling multiple nodes and bootmem allocation. It provides inline functions to map physical frame numbers (PFNs) to node IDs and pglist data structures, as well as setup functions for bootmem initialization and allocator configuration.

2 #define __ASM_SH_MMZONE_H

3

4 #ifdef __KERNEL__

5

6 #ifdef CONFIG_NEED_MULTIPLE_NODES

42 void __init plat_mem_setup(void);

43

44 /* arch/sh/kernel/setup.c */

45 void __init setup_bootmem_allocator(unsigned long start_pfn);

46 void __init __add_active_range(unsigned int nid, unsigned long start_pfn,

47 unsigned long end_pfn);

48

49 #endif /* __KERNEL__ */

50 #endif /* __ASM_SH_MMZONE_H */

51

x11.factor (git://github.com/x6j8x/factor.git) Unknown · 109 lines

2 ! See http://factorcode.org/license.txt for BSD license.

3 USING: accessors alien.c-types alien.data arrays kernel game.input

4 namespaces math classes bit-arrays system sequences vectors

5 x11 x11.xlib assocs generalizations ;

lpfc_sli.c (http://omnia2droid.googlecode.com/svn/trunk/) C · 11728 lines ✨ Summary

This C code is part of a Linux driver for a network interface card (NIC). It reads configuration data from the NIC and checks if certain ports are enabled or disabled. Specifically, it verifies the presence of a “PORT_STE” sub-TLV in the configuration region 23, which indicates whether the port is enabled or not. If the port is disabled, it sets a flag to indicate this.

824 int i, rc, ret = 0;

825

826 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);

827 if (!pmb)

828 return -ENOMEM;

989 spin_unlock_irq(&phba->hbalock);

990 new_arr = kzalloc(new_len * sizeof (struct lpfc_iocbq *),

991 GFP_KERNEL);

992 if (new_arr) {

993 spin_lock_irq(&phba->hbalock);

time.c (http://photon-android.googlecode.com/svn/) C · 152 lines ✨ Summary

This C code initializes a clock source for an Atmel AVR32 microcontroller, specifically the COUNT register. It sets up a clock event device to measure time intervals and generates interrupts at regular intervals. The clock source is rated as low quality due to potential issues with sleep states and CPU frequency changes. The code also prints information about the clock source and its associated IRQ.

11 #include <linux/interrupt.h>

12 #include <linux/irq.h>

13 #include <linux/kernel.h>

14 #include <linux/time.h>

15

mkmakefile (http://omnia2droid.googlecode.com/svn/trunk/) Shell · 51 lines ✨ Summary

This shell script generates a Makefile for a specific kernel source directory and output directory, based on provided version and patchlevel information. It checks if an existing Makefile exists in the output directory, and only overwrites it if necessary. The generated Makefile allows for building external modules and uses the `make` command to compile the kernel.

5

6 # Usage

7 # $1 - Kernel src directory

8 # $2 - Output directory

9 # $3 - version

13 test ! -r $2/Makefile -o -O $2/Makefile || exit 0

14 # Only overwrite automatically generated Makefiles

15 # (so we do not overwrite kernel Makefile)

16 if test -e $2/Makefile && ! grep -q Automatically $2/Makefile

17 then

mpc834x_itx.c (http://omnia2droid.googlecode.com/svn/trunk/) C · 114 lines ✨ Summary

This C code defines a Linux machine driver for the MPC834x ITX board, a variant of the PowerPC processor. It sets up the architecture, initializes interrupts, and detects compatibility with the device tree. The code also includes functions to probe the system, set up the PCI bus, and initialize USB configuration. It is part of the Linux kernel’s machine driver framework.

4 * MPC834x ITX board specific routines

5 *

6 * Maintainer: Kumar Gala <galak@kernel.crashing.org>

7 *

8 * This program is free software; you can redistribute it and/or modify it

13

14 #include <linux/stddef.h>

15 #include <linux/kernel.h>

16 #include <linux/init.h>

17 #include <linux/errno.h>

semaphores.factor (git://github.com/abeaumont/factor.git) Unknown · 39 lines

2 ! See http://factorcode.org/license.txt for BSD license.

3 USING: dlists kernel threads math concurrency.conditions

4 continuations accessors summary locals fry ;

5 IN: concurrency.semaphores

package.rkt (git://github.com/gmarceau/PLT.git) Racket · 445 lines ✨ Summary

This Racket code defines a set of syntaxes for working with packages, which are essentially namespaces that can be used to organize and export functions and variables. The `define-package` and `package-begin` macros create new packages, while the `open-package` and `open*-package` macros open existing ones. The `do-open` macro is a helper function for defining these syntaxes. It allows users to define package-related syntaxes in a concise way.

151 id

152 def-ctxes))]

153 [kernel-forms (list*

154 #'-define*-values

155 #'-define*-syntaxes

156 (kernel-form-identifier-list))]

157 [init-exprs (syntax->list #'(form ...))]

158 [new-bindings (make-bound-identifier-mapping)]

298 (let ([expr (local-expand (car exprs)

299 ctx

300 kernel-forms

301 def-ctxes)])

302 (syntax-case expr (begin)

addrspace.h (http://omnia2droid.googlecode.com/svn/trunk/) C++ Header · 65 lines ✨ Summary

This C header file defines address spaces for SH CPUs, specifically the SuperH processor family. It provides macros to manipulate addresses and determine if an address can be reached in 29 bits. The code is specific to the SH-4 processor and its store queues, providing a way to map addresses to different segments and check their validity.

11 #define __ASM_SH_ADDRSPACE_H

12

13 #ifdef __KERNEL__

14

15 #include <cpu/addrspace.h>

20 /*

21 [ P0/U0 (virtual) ] 0x00000000 <------ User space

22 [ P1 (fixed) cached ] 0x80000000 <------ Kernel space

23 [ P2 (fixed) non-cachable] 0xA0000000 <------ Physical access

24 [ P3 (virtual) cached] 0xC0000000 <------ vmalloced area

61 #endif

62

63 #endif /* __KERNEL__ */

64 #endif /* __ASM_SH_ADDRSPACE_H */

65

test_iplconvkernel.rb (git://github.com/ryanfb/ruby-opencv.git) Ruby · 54 lines ✨ Summary

This Ruby code defines a test suite for OpenCV’s `IplConvKernel` class, which represents a convolution kernel used in image processing. The tests verify that kernels can be created with different shapes and values, and that invalid arguments raise errors. It also checks the size and anchor of the kernel, ensuring they match the expected values.

11 def test_initialize

12 [:rect, :cross, :ellipse, CV_SHAPE_RECT, CV_SHAPE_CROSS, CV_SHAPE_ELLIPSE].each { |shape|

13 kernel = IplConvKernel.new(5, 5, 2, 2, shape)

14 assert_not_nil(kernel)

17 values = [1] * 25

18 [:custom, CV_SHAPE_CUSTOM].each { |shape|

19 kernel = IplConvKernel.new(5, 5, 2, 2, shape, values)

20 assert_not_nil(kernel)

33

34 def test_size

35 kernel = IplConvKernel.new(5, 4, 2, 2, :rect)

36 size = kernel.size

43

44 def test_anchor

45 kernel = IplConvKernel.new(5, 4, 3, 2, :rect)

46 a = kernel.anchor

machdep.c (https://bitbucket.org/freebsd/freebsd-head/) C · 785 lines ✨ Summary

This is a function that initializes a struct pcpu. It takes two arguments: pcpu, which is a pointer to a struct pcpu, and sz, which is the size of the struct pcpu. The function copies the SLB contents from the current CPU to the new struct pcpu.

251

252 uintptr_t

253 powerpc_init(vm_offset_t startkernel, vm_offset_t endkernel,

254 vm_offset_t basekernel, void *mdp)

294 boothowto = MD_FETCH(kmdp, MODINFOMD_HOWTO, int);

295 kern_envp = MD_FETCH(kmdp, MODINFOMD_ENVP, char *);

296 endkernel = ulmax(endkernel, MD_FETCH(kmdp,

297 MODINFOMD_KERNEND, vm_offset_t));

298 #ifdef DDB

422 /* Make sure the kernel icache is valid before we go too much further */

423 __syncicache((caddr_t)startkernel, endkernel - startkernel);

424

425 #ifndef __powerpc64__

555 pmap_mmu_install(MMU_TYPE_OEA, BUS_PROBE_GENERIC);

556

557 pmap_bootstrap(startkernel, endkernel);

558 mtmsr(PSL_KERNSET & ~PSL_EE);

559

symlink.c (http://photon-android.googlecode.com/svn/) C · 318 lines ✨ Summary

This C code implements a symlink file system operation for Linux. It allows creating and deleting symlinks, as well as following links to their target locations. The code provides functions for handling symlink operations, including `configfs_getlink` for getting the path of a linked file, `configfs_follow_link` for following a link, and `configfs_put_link` for releasing resources when a link is no longer needed.

81 goto out;

82 ret = -ENOMEM;

83 sl = kmalloc(sizeof(struct configfs_symlink), GFP_KERNEL);

84 if (sl) {

85 sl->sl_target = config_item_get(item);

286 {

287 int error = -ENOMEM;

288 unsigned long page = get_zeroed_page(GFP_KERNEL);

289

290 if (page) {

lapb_iface.c (http://photon-android.googlecode.com/svn/) C · 450 lines ✨ Summary

This C code implements the X.25 Link Access Procedure B (LAPB) link layer protocol for Linux. It provides functions for registering and unregistering LAPB devices, handling connection establishment and termination, data transmission and reception, and error handling. The code is designed to be used with the Linux kernel’s networking subsystem.

21 #include <linux/socket.h>

22 #include <linux/in.h>

23 #include <linux/kernel.h>

24 #include <linux/jiffies.h>

25 #include <linux/timer.h>

callback.c (http://photon-android.googlecode.com/svn/) C · 478 lines ✨ Summary

This C code implements a callback update process for a distributed file system, specifically for the Kerberos Authentication Service (KAS). It manages callbacks between the KAS and its clients, ensuring that updates are propagated correctly across the network. The code handles tasks such as updating vnode states, discarding expired callbacks, and rescheduling updates to minimize latency.

14 */

15

16 #include <linux/kernel.h>

17 #include <linux/module.h>

18 #include <linux/init.h>

utils.factor (git://github.com/mrjbq7/re-factor.git) Unknown · 88 lines

3

4 USING: accessors arrays assocs combinators fry generic

5 io.pathnames kernel lexer math math.functions math.order

6 math.parser math.private namespaces parser random sequences

7 sorting source-files tools.annotations ;

if_nfe.c (https://bitbucket.org/freebsd/freebsd-head/) C · 3374 lines ✨ Summary

This is a function that sets the Wake-on-LAN (WOL) settings for a network interface. It takes no arguments and returns nothing. The function first checks if the device has the Power Management Interface (PCI PM) capability, which is required for WOL. If it does, it then checks if the `IFCAP_WOL` flag is set in the interface’s capabilities, indicating that WOL is enabled. If so, it sets the `NFE_WOL_CTL` register to enable WOL and configures the MAC to have a 100Mbps, full-duplex link. It then enables RX and requests PME (Power Management Event) from the device’s power management controller if WOL is enabled. If the `IFCAP_WOL` flag is not set, it clears the `NFE_WOL_CTL` register to disable WOL.

24 __FBSDID("$FreeBSD$");

25

26 #ifdef HAVE_KERNEL_OPTION_HEADERS

27 #include "opt_device_polling.h"

28 #endif

35 #include <sys/malloc.h>

36 #include <sys/module.h>

37 #include <sys/kernel.h>

38 #include <sys/queue.h>

39 #include <sys/socket.h>

xts.c (http://photon-android.googlecode.com/svn/) C · 292 lines ✨ Summary

This C code implements the XTS (XEX-based Tweakable Block Cipher) block cipher mode for Linux. It provides a cryptographic algorithm that combines two AES keys to create a secure encryption scheme. The code defines a set of functions and data structures to manage the XTS algorithm, including initialization, encryption, and decryption operations.

17 #include <linux/err.h>

18 #include <linux/init.h>

19 #include <linux/kernel.h>

20 #include <linux/module.h>

21 #include <linux/scatterlist.h>

bug.h (http://omnia2droid.googlecode.com/svn/trunk/) C++ Header · 74 lines ✨ Summary

This C header file provides bug reporting functionality for the S390 architecture. It defines macros to emit a bug report, including `__EMIT_BUG` and `BUG`, which generate assembly code to print a message with the current file name and line number. The `WARN_ON` macro checks if a condition is true and emits a warning if it is. It also includes definitions for `HAVE_ARCH_BUG` and `HAVE_ARCH_WARN_ON`.

2 #define _ASM_S390_BUG_H

3

4 #include <linux/kernel.h>

5

6 #ifdef CONFIG_BUG

bar.dsp (https://swig.svn.sourceforge.net/svnroot/swig) Unknown · 147 lines

53 # ADD BSC32 /nologo

54 LINK32=link.exe

55 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /dll /debug /machine:I386 /pdbtype:sept

56 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib "$(RUBY_LIB)" /nologo /dll /debug /machine:I386 /out:"bar.dll" /pdbtype:sept

80 # ADD BSC32 /nologo

81 LINK32=link.exe

82 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /dll /machine:I386

83 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib "$(RUBY_LIB)" /nologo /dll /machine:I386 /out:"bar.dll"