Merge branch 'upstream'
This commit is contained in:
Jeff Garzik
commit
6e07e16404
477 changed files with 28019 additions and 7495 deletions
|
|
@ -19,20 +19,25 @@ struct fb_info;
|
|||
struct backlight_properties {
|
||||
/* Owner module */
|
||||
struct module *owner;
|
||||
/* Get the backlight power status (0: full on, 1..3: power saving
|
||||
modes; 4: full off), see FB_BLANK_XXX */
|
||||
int (*get_power)(struct backlight_device *);
|
||||
/* Enable or disable power to the LCD (0: on; 4: off, see FB_BLANK_XXX) */
|
||||
int (*set_power)(struct backlight_device *, int power);
|
||||
/* Maximal value for brightness (read-only) */
|
||||
int max_brightness;
|
||||
/* Get current backlight brightness */
|
||||
|
||||
/* Notify the backlight driver some property has changed */
|
||||
int (*update_status)(struct backlight_device *);
|
||||
/* Return the current backlight brightness (accounting for power,
|
||||
fb_blank etc.) */
|
||||
int (*get_brightness)(struct backlight_device *);
|
||||
/* Set backlight brightness (0..max_brightness) */
|
||||
int (*set_brightness)(struct backlight_device *, int brightness);
|
||||
/* Check if given framebuffer device is the one bound to this backlight;
|
||||
return 0 if not, !=0 if it is. If NULL, backlight always matches the fb. */
|
||||
int (*check_fb)(struct fb_info *);
|
||||
|
||||
/* Current User requested brightness (0 - max_brightness) */
|
||||
int brightness;
|
||||
/* Maximal value for brightness (read-only) */
|
||||
int max_brightness;
|
||||
/* Current FB Power mode (0: full on, 1..3: power saving
|
||||
modes; 4: full off), see FB_BLANK_XXX */
|
||||
int power;
|
||||
/* FB Blanking active? (values as for power) */
|
||||
int fb_blank;
|
||||
};
|
||||
|
||||
struct backlight_device {
|
||||
|
|
|
|||
|
|
@ -275,6 +275,7 @@ extern void d_move(struct dentry *, struct dentry *);
|
|||
/* appendix may either be NULL or be used for transname suffixes */
|
||||
extern struct dentry * d_lookup(struct dentry *, struct qstr *);
|
||||
extern struct dentry * __d_lookup(struct dentry *, struct qstr *);
|
||||
extern struct dentry * d_hash_and_lookup(struct dentry *, struct qstr *);
|
||||
|
||||
/* validate "insecure" dentry pointer */
|
||||
extern int d_validate(struct dentry *, struct dentry *);
|
||||
|
|
|
|||
|
|
@ -18,10 +18,4 @@
|
|||
#define POSIX_FADV_NOREUSE 5 /* Data will be accessed once. */
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Linux-specific fadvise() extensions:
|
||||
*/
|
||||
#define LINUX_FADV_ASYNC_WRITE 32 /* Start writeout on range */
|
||||
#define LINUX_FADV_WRITE_WAIT 33 /* Wait upon writeout to range */
|
||||
|
||||
#endif /* FADVISE_H_INCLUDED */
|
||||
|
|
|
|||
|
|
@ -839,12 +839,10 @@ struct fb_info {
|
|||
#define FB_LEFT_POS(bpp) (32 - bpp)
|
||||
#define FB_SHIFT_HIGH(val, bits) ((val) >> (bits))
|
||||
#define FB_SHIFT_LOW(val, bits) ((val) << (bits))
|
||||
#define FB_BIT_NR(b) (7 - (b))
|
||||
#else
|
||||
#define FB_LEFT_POS(bpp) (0)
|
||||
#define FB_SHIFT_HIGH(val, bits) ((val) << (bits))
|
||||
#define FB_SHIFT_LOW(val, bits) ((val) >> (bits))
|
||||
#define FB_BIT_NR(b) (b)
|
||||
#endif
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -757,6 +757,13 @@ extern void send_sigio(struct fown_struct *fown, int fd, int band);
|
|||
extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
|
||||
extern int fcntl_getlease(struct file *filp);
|
||||
|
||||
/* fs/sync.c */
|
||||
#define SYNC_FILE_RANGE_WAIT_BEFORE 1
|
||||
#define SYNC_FILE_RANGE_WRITE 2
|
||||
#define SYNC_FILE_RANGE_WAIT_AFTER 4
|
||||
extern int do_sync_file_range(struct file *file, loff_t offset, loff_t endbyte,
|
||||
int flags);
|
||||
|
||||
/* fs/locks.c */
|
||||
extern void locks_init_lock(struct file_lock *);
|
||||
extern void locks_copy_lock(struct file_lock *, struct file_lock *);
|
||||
|
|
@ -1032,6 +1039,8 @@ struct file_operations {
|
|||
int (*check_flags)(int);
|
||||
int (*dir_notify)(struct file *filp, unsigned long arg);
|
||||
int (*flock) (struct file *, int, struct file_lock *);
|
||||
ssize_t (*splice_write)(struct inode *, struct file *, size_t, unsigned int);
|
||||
ssize_t (*splice_read)(struct file *, struct inode *, size_t, unsigned int);
|
||||
};
|
||||
|
||||
struct inode_operations {
|
||||
|
|
@ -1411,6 +1420,7 @@ extern void bd_release_from_disk(struct block_device *, struct gendisk *);
|
|||
#endif
|
||||
|
||||
/* fs/char_dev.c */
|
||||
#define CHRDEV_MAJOR_HASH_SIZE 255
|
||||
extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
|
||||
extern int register_chrdev_region(dev_t, unsigned, const char *);
|
||||
extern int register_chrdev(unsigned int, const char *,
|
||||
|
|
@ -1418,25 +1428,17 @@ extern int register_chrdev(unsigned int, const char *,
|
|||
extern int unregister_chrdev(unsigned int, const char *);
|
||||
extern void unregister_chrdev_region(dev_t, unsigned);
|
||||
extern int chrdev_open(struct inode *, struct file *);
|
||||
extern int get_chrdev_list(char *);
|
||||
extern void *acquire_chrdev_list(void);
|
||||
extern int count_chrdev_list(void);
|
||||
extern void *get_next_chrdev(void *);
|
||||
extern int get_chrdev_info(void *, int *, char **);
|
||||
extern void release_chrdev_list(void *);
|
||||
extern void chrdev_show(struct seq_file *,off_t);
|
||||
|
||||
/* fs/block_dev.c */
|
||||
#define BLKDEV_MAJOR_HASH_SIZE 255
|
||||
#define BDEVNAME_SIZE 32 /* Largest string for a blockdev identifier */
|
||||
extern const char *__bdevname(dev_t, char *buffer);
|
||||
extern const char *bdevname(struct block_device *bdev, char *buffer);
|
||||
extern struct block_device *lookup_bdev(const char *);
|
||||
extern struct block_device *open_bdev_excl(const char *, int, void *);
|
||||
extern void close_bdev_excl(struct block_device *);
|
||||
extern void *acquire_blkdev_list(void);
|
||||
extern int count_blkdev_list(void);
|
||||
extern void *get_next_blkdev(void *);
|
||||
extern int get_blkdev_info(void *, int *, char **);
|
||||
extern void release_blkdev_list(void *);
|
||||
extern void blkdev_show(struct seq_file *,off_t);
|
||||
|
||||
extern void init_special_inode(struct inode *, umode_t, dev_t);
|
||||
|
||||
|
|
@ -1609,6 +1611,8 @@ extern ssize_t generic_file_sendfile(struct file *, loff_t *, size_t, read_actor
|
|||
extern void do_generic_mapping_read(struct address_space *mapping,
|
||||
struct file_ra_state *, struct file *,
|
||||
loff_t *, read_descriptor_t *, read_actor_t);
|
||||
extern ssize_t generic_file_splice_read(struct file *, struct inode *, size_t, unsigned int);
|
||||
extern ssize_t generic_file_splice_write(struct inode *, struct file *, size_t, unsigned int);
|
||||
extern void
|
||||
file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
|
||||
extern ssize_t generic_file_readv(struct file *filp, const struct iovec *iov,
|
||||
|
|
|
|||
|
|
@ -57,6 +57,19 @@ struct hrtimer {
|
|||
struct hrtimer_base *base;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct hrtimer_sleeper - simple sleeper structure
|
||||
*
|
||||
* @timer: embedded timer structure
|
||||
* @task: task to wake up
|
||||
*
|
||||
* task is set to NULL, when the timer expires.
|
||||
*/
|
||||
struct hrtimer_sleeper {
|
||||
struct hrtimer timer;
|
||||
struct task_struct *task;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct hrtimer_base - the timer base for a specific clock
|
||||
*
|
||||
|
|
@ -127,6 +140,9 @@ extern long hrtimer_nanosleep(struct timespec *rqtp,
|
|||
const enum hrtimer_mode mode,
|
||||
const clockid_t clockid);
|
||||
|
||||
extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl,
|
||||
struct task_struct *tsk);
|
||||
|
||||
/* Soft interrupt function to run the hrtimer queues: */
|
||||
extern void hrtimer_run_queues(void);
|
||||
|
||||
|
|
|
|||
|
|
@ -82,6 +82,13 @@ struct ipmi_smi_handlers
|
|||
{
|
||||
struct module *owner;
|
||||
|
||||
/* The low-level interface cannot start sending messages to
|
||||
the upper layer until this function is called. This may
|
||||
not be NULL, the lower layer must take the interface from
|
||||
this call. */
|
||||
int (*start_processing)(void *send_info,
|
||||
ipmi_smi_t new_intf);
|
||||
|
||||
/* Called to enqueue an SMI message to be sent. This
|
||||
operation is not allowed to fail. If an error occurs, it
|
||||
should report back the error in a received message. It may
|
||||
|
|
@ -157,13 +164,16 @@ static inline void ipmi_demangle_device_id(unsigned char *data,
|
|||
}
|
||||
|
||||
/* Add a low-level interface to the IPMI driver. Note that if the
|
||||
interface doesn't know its slave address, it should pass in zero. */
|
||||
interface doesn't know its slave address, it should pass in zero.
|
||||
The low-level interface should not deliver any messages to the
|
||||
upper layer until the start_processing() function in the handlers
|
||||
is called, and the lower layer must get the interface from that
|
||||
call. */
|
||||
int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
|
||||
void *send_info,
|
||||
struct ipmi_device_id *device_id,
|
||||
struct device *dev,
|
||||
unsigned char slave_addr,
|
||||
ipmi_smi_t *intf);
|
||||
unsigned char slave_addr);
|
||||
|
||||
/*
|
||||
* Remove a low-level interface from the IPMI driver. This will
|
||||
|
|
|
|||
111
include/linux/leds.h
Normal file
111
include/linux/leds.h
Normal file
|
|
@ -0,0 +1,111 @@
|
|||
/*
|
||||
* Driver model for leds and led triggers
|
||||
*
|
||||
* Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
|
||||
* Copyright (C) 2005 Richard Purdie <rpurdie@openedhand.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
*/
|
||||
#ifndef __LINUX_LEDS_H_INCLUDED
|
||||
#define __LINUX_LEDS_H_INCLUDED
|
||||
|
||||
struct device;
|
||||
struct class_device;
|
||||
/*
|
||||
* LED Core
|
||||
*/
|
||||
|
||||
enum led_brightness {
|
||||
LED_OFF = 0,
|
||||
LED_HALF = 127,
|
||||
LED_FULL = 255,
|
||||
};
|
||||
|
||||
struct led_classdev {
|
||||
const char *name;
|
||||
int brightness;
|
||||
int flags;
|
||||
#define LED_SUSPENDED (1 << 0)
|
||||
|
||||
/* A function to set the brightness of the led */
|
||||
void (*brightness_set)(struct led_classdev *led_cdev,
|
||||
enum led_brightness brightness);
|
||||
|
||||
struct class_device *class_dev;
|
||||
/* LED Device linked list */
|
||||
struct list_head node;
|
||||
|
||||
/* Trigger data */
|
||||
char *default_trigger;
|
||||
#ifdef CONFIG_LEDS_TRIGGERS
|
||||
rwlock_t trigger_lock;
|
||||
/* Protects the trigger data below */
|
||||
|
||||
struct led_trigger *trigger;
|
||||
struct list_head trig_list;
|
||||
void *trigger_data;
|
||||
#endif
|
||||
};
|
||||
|
||||
extern int led_classdev_register(struct device *parent,
|
||||
struct led_classdev *led_cdev);
|
||||
extern void led_classdev_unregister(struct led_classdev *led_cdev);
|
||||
extern void led_classdev_suspend(struct led_classdev *led_cdev);
|
||||
extern void led_classdev_resume(struct led_classdev *led_cdev);
|
||||
|
||||
/*
|
||||
* LED Triggers
|
||||
*/
|
||||
#ifdef CONFIG_LEDS_TRIGGERS
|
||||
|
||||
#define TRIG_NAME_MAX 50
|
||||
|
||||
struct led_trigger {
|
||||
/* Trigger Properties */
|
||||
const char *name;
|
||||
void (*activate)(struct led_classdev *led_cdev);
|
||||
void (*deactivate)(struct led_classdev *led_cdev);
|
||||
|
||||
/* LEDs under control by this trigger (for simple triggers) */
|
||||
rwlock_t leddev_list_lock;
|
||||
struct list_head led_cdevs;
|
||||
|
||||
/* Link to next registered trigger */
|
||||
struct list_head next_trig;
|
||||
};
|
||||
|
||||
/* Registration functions for complex triggers */
|
||||
extern int led_trigger_register(struct led_trigger *trigger);
|
||||
extern void led_trigger_unregister(struct led_trigger *trigger);
|
||||
|
||||
/* Registration functions for simple triggers */
|
||||
#define DEFINE_LED_TRIGGER(x) static struct led_trigger *x;
|
||||
#define DEFINE_LED_TRIGGER_GLOBAL(x) struct led_trigger *x;
|
||||
extern void led_trigger_register_simple(const char *name,
|
||||
struct led_trigger **trigger);
|
||||
extern void led_trigger_unregister_simple(struct led_trigger *trigger);
|
||||
extern void led_trigger_event(struct led_trigger *trigger,
|
||||
enum led_brightness event);
|
||||
|
||||
#else
|
||||
|
||||
/* Triggers aren't active - null macros */
|
||||
#define DEFINE_LED_TRIGGER(x)
|
||||
#define DEFINE_LED_TRIGGER_GLOBAL(x)
|
||||
#define led_trigger_register_simple(x, y) do {} while(0)
|
||||
#define led_trigger_unregister_simple(x) do {} while(0)
|
||||
#define led_trigger_event(x, y) do {} while(0)
|
||||
|
||||
#endif
|
||||
|
||||
/* Trigger specific functions */
|
||||
#ifdef CONFIG_LEDS_TRIGGER_IDE_DISK
|
||||
extern void ledtrig_ide_activity(void);
|
||||
#else
|
||||
#define ledtrig_ide_activity() do {} while(0)
|
||||
#endif
|
||||
|
||||
#endif /* __LINUX_LEDS_H_INCLUDED */
|
||||
|
|
@ -668,14 +668,24 @@ static inline unsigned int ata_tag_valid(unsigned int tag)
|
|||
return (tag < ATA_MAX_QUEUE) ? 1 : 0;
|
||||
}
|
||||
|
||||
static inline unsigned int ata_class_present(unsigned int class)
|
||||
static inline unsigned int ata_class_enabled(unsigned int class)
|
||||
{
|
||||
return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI;
|
||||
}
|
||||
|
||||
static inline unsigned int ata_dev_present(const struct ata_device *dev)
|
||||
static inline unsigned int ata_class_disabled(unsigned int class)
|
||||
{
|
||||
return ata_class_present(dev->class);
|
||||
return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP;
|
||||
}
|
||||
|
||||
static inline unsigned int ata_dev_enabled(const struct ata_device *dev)
|
||||
{
|
||||
return ata_class_enabled(dev->class);
|
||||
}
|
||||
|
||||
static inline unsigned int ata_dev_disabled(const struct ata_device *dev)
|
||||
{
|
||||
return ata_class_disabled(dev->class);
|
||||
}
|
||||
|
||||
static inline u8 ata_chk_status(struct ata_port *ap)
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ extern void migrate_page_copy(struct page *, struct page *);
|
|||
extern int migrate_page_remove_references(struct page *, struct page *, int);
|
||||
extern int migrate_pages(struct list_head *l, struct list_head *t,
|
||||
struct list_head *moved, struct list_head *failed);
|
||||
int migrate_pages_to(struct list_head *pagelist,
|
||||
extern int migrate_pages_to(struct list_head *pagelist,
|
||||
struct vm_area_struct *vma, int dest);
|
||||
extern int fail_migrate_page(struct page *, struct page *);
|
||||
|
||||
|
|
@ -26,6 +26,9 @@ static inline int putback_lru_pages(struct list_head *l) { return 0; }
|
|||
static inline int migrate_pages(struct list_head *l, struct list_head *t,
|
||||
struct list_head *moved, struct list_head *failed) { return -ENOSYS; }
|
||||
|
||||
static inline int migrate_pages_to(struct list_head *pagelist,
|
||||
struct vm_area_struct *vma, int dest) { return 0; }
|
||||
|
||||
static inline int migrate_prep(void) { return -ENOSYS; }
|
||||
|
||||
/* Possible settings for the migrate_page() method in address_operations */
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
#ifndef __MTD_TRANS_H__
|
||||
#define __MTD_TRANS_H__
|
||||
|
||||
#include <asm/semaphore.h>
|
||||
#include <linux/mutex.h>
|
||||
|
||||
struct hd_geometry;
|
||||
struct mtd_info;
|
||||
|
|
@ -22,7 +22,7 @@ struct mtd_blktrans_dev {
|
|||
struct mtd_blktrans_ops *tr;
|
||||
struct list_head list;
|
||||
struct mtd_info *mtd;
|
||||
struct semaphore sem;
|
||||
struct mutex lock;
|
||||
int devnum;
|
||||
int blksize;
|
||||
unsigned long size;
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
#define __MTD_DOC2000_H__
|
||||
|
||||
#include <linux/mtd/mtd.h>
|
||||
#include <asm/semaphore.h>
|
||||
#include <linux/mutex.h>
|
||||
|
||||
#define DoC_Sig1 0
|
||||
#define DoC_Sig2 1
|
||||
|
|
@ -187,7 +187,7 @@ struct DiskOnChip {
|
|||
int numchips;
|
||||
struct Nand *chips;
|
||||
struct mtd_info *nextdoc;
|
||||
struct semaphore lock;
|
||||
struct mutex lock;
|
||||
};
|
||||
|
||||
int doc_decode_ecc(unsigned char sector[512], unsigned char ecc1[6]);
|
||||
|
|
|
|||
|
|
@ -52,6 +52,11 @@ struct INFTLrecord {
|
|||
int INFTL_mount(struct INFTLrecord *s);
|
||||
int INFTL_formatblock(struct INFTLrecord *s, int block);
|
||||
|
||||
extern char inftlmountrev[];
|
||||
|
||||
void INFTL_dumptables(struct INFTLrecord *s);
|
||||
void INFTL_dumpVUchains(struct INFTLrecord *s);
|
||||
|
||||
#endif /* __KERNEL__ */
|
||||
|
||||
#endif /* __MTD_INFTL_H__ */
|
||||
|
|
|
|||
|
|
@ -75,7 +75,6 @@ extern struct file *nameidata_to_filp(struct nameidata *nd, int flags);
|
|||
extern void release_open_intent(struct nameidata *);
|
||||
|
||||
extern struct dentry * lookup_one_len(const char *, struct dentry *, int);
|
||||
extern __deprecated_for_modules struct dentry * lookup_hash(struct nameidata *);
|
||||
|
||||
extern int follow_down(struct vfsmount **, struct dentry **);
|
||||
extern int follow_up(struct vfsmount **, struct dentry **);
|
||||
|
|
|
|||
|
|
@ -598,20 +598,7 @@ DECLARE_PER_CPU(struct softnet_data,softnet_data);
|
|||
|
||||
#define HAVE_NETIF_QUEUE
|
||||
|
||||
static inline void __netif_schedule(struct net_device *dev)
|
||||
{
|
||||
if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
|
||||
unsigned long flags;
|
||||
struct softnet_data *sd;
|
||||
|
||||
local_irq_save(flags);
|
||||
sd = &__get_cpu_var(softnet_data);
|
||||
dev->next_sched = sd->output_queue;
|
||||
sd->output_queue = dev;
|
||||
raise_softirq_irqoff(NET_TX_SOFTIRQ);
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
}
|
||||
extern void __netif_schedule(struct net_device *dev);
|
||||
|
||||
static inline void netif_schedule(struct net_device *dev)
|
||||
{
|
||||
|
|
@ -675,13 +662,7 @@ static inline void dev_kfree_skb_irq(struct sk_buff *skb)
|
|||
/* Use this variant in places where it could be invoked
|
||||
* either from interrupt or non-interrupt context.
|
||||
*/
|
||||
static inline void dev_kfree_skb_any(struct sk_buff *skb)
|
||||
{
|
||||
if (in_irq() || irqs_disabled())
|
||||
dev_kfree_skb_irq(skb);
|
||||
else
|
||||
dev_kfree_skb(skb);
|
||||
}
|
||||
extern void dev_kfree_skb_any(struct sk_buff *skb);
|
||||
|
||||
#define HAVE_NETIF_RX 1
|
||||
extern int netif_rx(struct sk_buff *skb);
|
||||
|
|
@ -768,22 +749,9 @@ static inline int netif_device_present(struct net_device *dev)
|
|||
return test_bit(__LINK_STATE_PRESENT, &dev->state);
|
||||
}
|
||||
|
||||
static inline void netif_device_detach(struct net_device *dev)
|
||||
{
|
||||
if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
|
||||
netif_running(dev)) {
|
||||
netif_stop_queue(dev);
|
||||
}
|
||||
}
|
||||
extern void netif_device_detach(struct net_device *dev);
|
||||
|
||||
static inline void netif_device_attach(struct net_device *dev)
|
||||
{
|
||||
if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
|
||||
netif_running(dev)) {
|
||||
netif_wake_queue(dev);
|
||||
__netdev_watchdog_up(dev);
|
||||
}
|
||||
}
|
||||
extern void netif_device_attach(struct net_device *dev);
|
||||
|
||||
/*
|
||||
* Network interface message level settings
|
||||
|
|
@ -851,20 +819,7 @@ static inline int netif_rx_schedule_prep(struct net_device *dev)
|
|||
* already been called and returned 1.
|
||||
*/
|
||||
|
||||
static inline void __netif_rx_schedule(struct net_device *dev)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
||||
local_irq_save(flags);
|
||||
dev_hold(dev);
|
||||
list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
|
||||
if (dev->quota < 0)
|
||||
dev->quota += dev->weight;
|
||||
else
|
||||
dev->quota = dev->weight;
|
||||
__raise_softirq_irqoff(NET_RX_SOFTIRQ);
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
extern void __netif_rx_schedule(struct net_device *dev);
|
||||
|
||||
/* Try to reschedule poll. Called by irq handler. */
|
||||
|
||||
|
|
|
|||
|
|
@ -72,8 +72,8 @@ extern struct page * find_get_page(struct address_space *mapping,
|
|||
unsigned long index);
|
||||
extern struct page * find_lock_page(struct address_space *mapping,
|
||||
unsigned long index);
|
||||
extern struct page * find_trylock_page(struct address_space *mapping,
|
||||
unsigned long index);
|
||||
extern __deprecated_for_modules struct page * find_trylock_page(
|
||||
struct address_space *mapping, unsigned long index);
|
||||
extern struct page * find_or_create_page(struct address_space *mapping,
|
||||
unsigned long index, gfp_t gfp_mask);
|
||||
unsigned find_get_pages(struct address_space *mapping, pgoff_t start,
|
||||
|
|
|
|||
|
|
@ -1,6 +1,8 @@
|
|||
#ifndef _LINUX_PID_H
|
||||
#define _LINUX_PID_H
|
||||
|
||||
#include <linux/rcupdate.h>
|
||||
|
||||
enum pid_type
|
||||
{
|
||||
PIDTYPE_PID,
|
||||
|
|
@ -9,45 +11,109 @@ enum pid_type
|
|||
PIDTYPE_MAX
|
||||
};
|
||||
|
||||
/*
|
||||
* What is struct pid?
|
||||
*
|
||||
* A struct pid is the kernel's internal notion of a process identifier.
|
||||
* It refers to individual tasks, process groups, and sessions. While
|
||||
* there are processes attached to it the struct pid lives in a hash
|
||||
* table, so it and then the processes that it refers to can be found
|
||||
* quickly from the numeric pid value. The attached processes may be
|
||||
* quickly accessed by following pointers from struct pid.
|
||||
*
|
||||
* Storing pid_t values in the kernel and refering to them later has a
|
||||
* problem. The process originally with that pid may have exited and the
|
||||
* pid allocator wrapped, and another process could have come along
|
||||
* and been assigned that pid.
|
||||
*
|
||||
* Referring to user space processes by holding a reference to struct
|
||||
* task_struct has a problem. When the user space process exits
|
||||
* the now useless task_struct is still kept. A task_struct plus a
|
||||
* stack consumes around 10K of low kernel memory. More precisely
|
||||
* this is THREAD_SIZE + sizeof(struct task_struct). By comparison
|
||||
* a struct pid is about 64 bytes.
|
||||
*
|
||||
* Holding a reference to struct pid solves both of these problems.
|
||||
* It is small so holding a reference does not consume a lot of
|
||||
* resources, and since a new struct pid is allocated when the numeric
|
||||
* pid value is reused we don't mistakenly refer to new processes.
|
||||
*/
|
||||
|
||||
struct pid
|
||||
{
|
||||
atomic_t count;
|
||||
/* Try to keep pid_chain in the same cacheline as nr for find_pid */
|
||||
int nr;
|
||||
struct hlist_node pid_chain;
|
||||
/* list of pids with the same nr, only one of them is in the hash */
|
||||
struct list_head pid_list;
|
||||
/* lists of tasks that use this pid */
|
||||
struct hlist_head tasks[PIDTYPE_MAX];
|
||||
struct rcu_head rcu;
|
||||
};
|
||||
|
||||
#define pid_task(elem, type) \
|
||||
list_entry(elem, struct task_struct, pids[type].pid_list)
|
||||
struct pid_link
|
||||
{
|
||||
struct hlist_node node;
|
||||
struct pid *pid;
|
||||
};
|
||||
|
||||
static inline struct pid *get_pid(struct pid *pid)
|
||||
{
|
||||
if (pid)
|
||||
atomic_inc(&pid->count);
|
||||
return pid;
|
||||
}
|
||||
|
||||
extern void FASTCALL(put_pid(struct pid *pid));
|
||||
extern struct task_struct *FASTCALL(pid_task(struct pid *pid, enum pid_type));
|
||||
extern struct task_struct *FASTCALL(get_pid_task(struct pid *pid,
|
||||
enum pid_type));
|
||||
|
||||
/*
|
||||
* attach_pid() and detach_pid() must be called with the tasklist_lock
|
||||
* write-held.
|
||||
*/
|
||||
extern int FASTCALL(attach_pid(struct task_struct *task, enum pid_type type, int nr));
|
||||
extern int FASTCALL(attach_pid(struct task_struct *task,
|
||||
enum pid_type type, int nr));
|
||||
|
||||
extern void FASTCALL(detach_pid(struct task_struct *task, enum pid_type));
|
||||
|
||||
/*
|
||||
* look up a PID in the hash table. Must be called with the tasklist_lock
|
||||
* held.
|
||||
* or rcu_read_lock() held.
|
||||
*/
|
||||
extern struct pid *FASTCALL(find_pid(enum pid_type, int));
|
||||
extern struct pid *FASTCALL(find_pid(int nr));
|
||||
|
||||
extern int alloc_pidmap(void);
|
||||
extern void FASTCALL(free_pidmap(int));
|
||||
/*
|
||||
* Lookup a PID in the hash table, and return with it's count elevated.
|
||||
*/
|
||||
extern struct pid *find_get_pid(int nr);
|
||||
|
||||
extern struct pid *alloc_pid(void);
|
||||
extern void FASTCALL(free_pid(struct pid *pid));
|
||||
|
||||
#define pid_next(task, type) \
|
||||
((task)->pids[(type)].node.next)
|
||||
|
||||
#define pid_next_task(task, type) \
|
||||
hlist_entry(pid_next(task, type), struct task_struct, \
|
||||
pids[(type)].node)
|
||||
|
||||
|
||||
/* We could use hlist_for_each_entry_rcu here but it takes more arguments
|
||||
* than the do_each_task_pid/while_each_task_pid. So we roll our own
|
||||
* to preserve the existing interface.
|
||||
*/
|
||||
#define do_each_task_pid(who, type, task) \
|
||||
if ((task = find_task_by_pid_type(type, who))) { \
|
||||
prefetch((task)->pids[type].pid_list.next); \
|
||||
prefetch(pid_next(task, type)); \
|
||||
do {
|
||||
|
||||
#define while_each_task_pid(who, type, task) \
|
||||
} while (task = pid_task((task)->pids[type].pid_list.next,\
|
||||
type), \
|
||||
prefetch((task)->pids[type].pid_list.next), \
|
||||
hlist_unhashed(&(task)->pids[type].pid_chain)); \
|
||||
} \
|
||||
} while (pid_next(task, type) && ({ \
|
||||
task = pid_next_task(task, type); \
|
||||
rcu_dereference(task); \
|
||||
prefetch(pid_next(task, type)); \
|
||||
1; }) ); \
|
||||
}
|
||||
|
||||
#endif /* _LINUX_PID_H */
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@ struct pipe_buffer {
|
|||
struct page *page;
|
||||
unsigned int offset, len;
|
||||
struct pipe_buf_operations *ops;
|
||||
unsigned int stolen;
|
||||
};
|
||||
|
||||
struct pipe_buf_operations {
|
||||
|
|
@ -16,6 +17,7 @@ struct pipe_buf_operations {
|
|||
void * (*map)(struct file *, struct pipe_inode_info *, struct pipe_buffer *);
|
||||
void (*unmap)(struct pipe_inode_info *, struct pipe_buffer *);
|
||||
void (*release)(struct pipe_inode_info *, struct pipe_buffer *);
|
||||
int (*steal)(struct pipe_inode_info *, struct pipe_buffer *);
|
||||
};
|
||||
|
||||
struct pipe_inode_info {
|
||||
|
|
@ -53,4 +55,10 @@ void pipe_wait(struct inode * inode);
|
|||
struct inode* pipe_new(struct inode* inode);
|
||||
void free_pipe_info(struct inode* inode);
|
||||
|
||||
/*
|
||||
* splice is tied to pipes as a transport (at least for now), so we'll just
|
||||
* add the splice flags here.
|
||||
*/
|
||||
#define SPLICE_F_MOVE (0x01) /* move pages instead of copying */
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -100,6 +100,7 @@ DECLARE_PER_CPU(unsigned long, process_counts);
|
|||
extern int nr_processes(void);
|
||||
extern unsigned long nr_running(void);
|
||||
extern unsigned long nr_uninterruptible(void);
|
||||
extern unsigned long nr_active(void);
|
||||
extern unsigned long nr_iowait(void);
|
||||
|
||||
#include <linux/time.h>
|
||||
|
|
@ -483,6 +484,7 @@ struct signal_struct {
|
|||
#define MAX_PRIO (MAX_RT_PRIO + 40)
|
||||
|
||||
#define rt_task(p) (unlikely((p)->prio < MAX_RT_PRIO))
|
||||
#define batch_task(p) (unlikely((p)->policy == SCHED_BATCH))
|
||||
|
||||
/*
|
||||
* Some day this will be a full-fledged user tracking system..
|
||||
|
|
@ -683,6 +685,13 @@ static inline void prefetch_stack(struct task_struct *t) { }
|
|||
struct audit_context; /* See audit.c */
|
||||
struct mempolicy;
|
||||
|
||||
enum sleep_type {
|
||||
SLEEP_NORMAL,
|
||||
SLEEP_NONINTERACTIVE,
|
||||
SLEEP_INTERACTIVE,
|
||||
SLEEP_INTERRUPTED,
|
||||
};
|
||||
|
||||
struct task_struct {
|
||||
volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */
|
||||
struct thread_info *thread_info;
|
||||
|
|
@ -705,7 +714,7 @@ struct task_struct {
|
|||
unsigned long sleep_avg;
|
||||
unsigned long long timestamp, last_ran;
|
||||
unsigned long long sched_time; /* sched_clock time spent running */
|
||||
int activated;
|
||||
enum sleep_type sleep_type;
|
||||
|
||||
unsigned long policy;
|
||||
cpumask_t cpus_allowed;
|
||||
|
|
@ -751,7 +760,7 @@ struct task_struct {
|
|||
struct task_struct *group_leader; /* threadgroup leader */
|
||||
|
||||
/* PID/PID hash table linkage. */
|
||||
struct pid pids[PIDTYPE_MAX];
|
||||
struct pid_link pids[PIDTYPE_MAX];
|
||||
struct list_head thread_group;
|
||||
|
||||
struct completion *vfork_done; /* for vfork() */
|
||||
|
|
@ -890,18 +899,19 @@ static inline pid_t process_group(struct task_struct *tsk)
|
|||
*/
|
||||
static inline int pid_alive(struct task_struct *p)
|
||||
{
|
||||
return p->pids[PIDTYPE_PID].nr != 0;
|
||||
return p->pids[PIDTYPE_PID].pid != NULL;
|
||||
}
|
||||
|
||||
extern void free_task(struct task_struct *tsk);
|
||||
#define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
|
||||
|
||||
extern void __put_task_struct_cb(struct rcu_head *rhp);
|
||||
extern void __put_task_struct(struct task_struct *t);
|
||||
|
||||
static inline void put_task_struct(struct task_struct *t)
|
||||
{
|
||||
if (atomic_dec_and_test(&t->usage))
|
||||
call_rcu(&t->rcu, __put_task_struct_cb);
|
||||
__put_task_struct(t);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -941,6 +941,25 @@ static inline void skb_reserve(struct sk_buff *skb, int len)
|
|||
#define NET_IP_ALIGN 2
|
||||
#endif
|
||||
|
||||
/*
|
||||
* The networking layer reserves some headroom in skb data (via
|
||||
* dev_alloc_skb). This is used to avoid having to reallocate skb data when
|
||||
* the header has to grow. In the default case, if the header has to grow
|
||||
* 16 bytes or less we avoid the reallocation.
|
||||
*
|
||||
* Unfortunately this headroom changes the DMA alignment of the resulting
|
||||
* network packet. As for NET_IP_ALIGN, this unaligned DMA is expensive
|
||||
* on some architectures. An architecture can override this value,
|
||||
* perhaps setting it to a cacheline in size (since that will maintain
|
||||
* cacheline alignment of the DMA). It must be a power of 2.
|
||||
*
|
||||
* Various parts of the networking layer expect at least 16 bytes of
|
||||
* headroom, you should not reduce this.
|
||||
*/
|
||||
#ifndef NET_SKB_PAD
|
||||
#define NET_SKB_PAD 16
|
||||
#endif
|
||||
|
||||
extern int ___pskb_trim(struct sk_buff *skb, unsigned int len, int realloc);
|
||||
|
||||
static inline void __skb_trim(struct sk_buff *skb, unsigned int len)
|
||||
|
|
@ -1030,9 +1049,9 @@ static inline void __skb_queue_purge(struct sk_buff_head *list)
|
|||
static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
|
||||
gfp_t gfp_mask)
|
||||
{
|
||||
struct sk_buff *skb = alloc_skb(length + 16, gfp_mask);
|
||||
struct sk_buff *skb = alloc_skb(length + NET_SKB_PAD, gfp_mask);
|
||||
if (likely(skb))
|
||||
skb_reserve(skb, 16);
|
||||
skb_reserve(skb, NET_SKB_PAD);
|
||||
return skb;
|
||||
}
|
||||
#else
|
||||
|
|
@ -1070,13 +1089,15 @@ static inline struct sk_buff *dev_alloc_skb(unsigned int length)
|
|||
*/
|
||||
static inline int skb_cow(struct sk_buff *skb, unsigned int headroom)
|
||||
{
|
||||
int delta = (headroom > 16 ? headroom : 16) - skb_headroom(skb);
|
||||
int delta = (headroom > NET_SKB_PAD ? headroom : NET_SKB_PAD) -
|
||||
skb_headroom(skb);
|
||||
|
||||
if (delta < 0)
|
||||
delta = 0;
|
||||
|
||||
if (delta || skb_cloned(skb))
|
||||
return pskb_expand_head(skb, (delta + 15) & ~15, 0, GFP_ATOMIC);
|
||||
return pskb_expand_head(skb, (delta + (NET_SKB_PAD-1)) &
|
||||
~(NET_SKB_PAD-1), 0, GFP_ATOMIC);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -569,5 +569,9 @@ asmlinkage long compat_sys_newfstatat(unsigned int dfd, char __user * filename,
|
|||
asmlinkage long compat_sys_openat(unsigned int dfd, const char __user *filename,
|
||||
int flags, int mode);
|
||||
asmlinkage long sys_unshare(unsigned long unshare_flags);
|
||||
asmlinkage long sys_splice(int fdin, int fdout, size_t len,
|
||||
unsigned int flags);
|
||||
asmlinkage long sys_sync_file_range(int fd, loff_t offset, loff_t nbytes,
|
||||
int flags);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
#include <linux/spinlock.h>
|
||||
#include <linux/stddef.h>
|
||||
|
||||
struct timer_base_s;
|
||||
struct tvec_t_base_s;
|
||||
|
||||
struct timer_list {
|
||||
struct list_head entry;
|
||||
|
|
@ -15,16 +15,16 @@ struct timer_list {
|
|||
void (*function)(unsigned long);
|
||||
unsigned long data;
|
||||
|
||||
struct timer_base_s *base;
|
||||
struct tvec_t_base_s *base;
|
||||
};
|
||||
|
||||
extern struct timer_base_s __init_timer_base;
|
||||
extern struct tvec_t_base_s boot_tvec_bases;
|
||||
|
||||
#define TIMER_INITIALIZER(_function, _expires, _data) { \
|
||||
.function = (_function), \
|
||||
.expires = (_expires), \
|
||||
.data = (_data), \
|
||||
.base = &__init_timer_base, \
|
||||
.base = &boot_tvec_bases, \
|
||||
}
|
||||
|
||||
#define DEFINE_TIMER(_name, _function, _expires, _data) \
|
||||
|
|
|
|||
|
|
@ -34,5 +34,6 @@ struct tiocl_selection {
|
|||
#define TIOCL_SCROLLCONSOLE 13 /* scroll console */
|
||||
#define TIOCL_BLANKSCREEN 14 /* keep screen blank even if a key is pressed */
|
||||
#define TIOCL_BLANKEDSCREEN 15 /* return which vt was blanked */
|
||||
#define TIOCL_GETKMSGREDIRECT 17 /* get the vt the kernel messages are restricted to */
|
||||
|
||||
#endif /* _LINUX_TIOCL_H */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue