static struct hd_struct acsi_part[MAX_DEV<<4] = { {0,0}, };
static int access_count[MAX_DEV] = { 0, };
static char busy[MAX_DEV] = { 0, };
-static struct wait_queue *busy_wait;
+static DECLARE_WAIT_QUEUE_HEAD(busy_wait);
static int CurrentNReq;
static int CurrentNSect;
static int SLMError;
/* wait queues */
-static struct wait_queue *slm_wait; /* waiting for buffer */
-static struct wait_queue *print_wait; /* waiting for printing finished */
+static DECLARE_WAIT_QUEUE_HEAD(slm_wait); /* waiting for buffer */
+static DECLARE_WAIT_QUEUE_HEAD(print_wait); /* waiting for printing finished */
/* status codes */
#define SLMSTAT_OK 0x00
/* request loop (trackbuffer) */
static volatile int fdc_busy = -1;
static volatile int fdc_nested = 0;
-static struct wait_queue *fdc_wait = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
-static struct wait_queue *motor_wait = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(motor_wait);
static volatile int selected = -1; /* currently selected drive */
* request.
*/
static volatile char block_flag = 0;
-static struct wait_queue *wait_fd_block = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(wait_fd_block);
/* MS-Dos MFM Coding tables (should go quick and easy) */
static unsigned char mfmencode[16]={
/* floppy internal millisecond timer stuff */
static volatile int ms_busy = -1;
-static struct wait_queue *ms_wait = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(ms_wait);
#define MS_TICKS ((amiga_eclock+50)/1000)
/*
/* Synchronization of FDC access. */
static volatile int fdc_busy = 0;
-static struct wait_queue *fdc_wait = NULL;
-static struct wait_queue *format_wait = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
+static DECLARE_WAIT_QUEUE_HEAD(format_wait);
static unsigned int changed_floppies = 0xff, fake_change = 0;
#define CHECK_CHANGE_DELAY HZ/2
u_int dma_arb_level; /* DMA arbitration level */
-static struct wait_queue *ps2esdi_int = NULL, *ps2esdi_wait_open = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(ps2esdi_int);
+static DECLARE_WAIT_QUEUE_HEAD(ps2esdi_wait_open);
+
int no_int_yet;
static int access_count[MAX_HD] = {0,};
static char ps2esdi_valid[MAX_HD] = {0,};
void __wait_on_stripe(struct stripe_head *sh)
{
- struct wait_queue wait = { current, NULL };
+ DECLARE_WAITQUEUE(wait, current);
PRINTK(("wait_on_stripe %lu\n", sh->sector));
sh->count++;
goto abort;
memset(raid_conf->stripe_hashtbl, 0, HASH_PAGES * PAGE_SIZE);
- init_waitqueue(&raid_conf->wait_for_stripe);
+ init_waitqueue_head(&raid_conf->wait_for_stripe);
PRINTK(("raid5_run(%d) called.\n", minor));
for (i = 0; i < mddev->nb_dev; i++) {
struct timer_list timeout;
int timeout_pending;
int ejected;
- struct wait_queue *wait;
+ wait_queue_head_t wait;
int wanted;
struct device_node* media_bay; /* NULL when not in bay */
char dbdma_cmd_space[5 * sizeof(struct dbdma_cmd)];
fs->secpertrack = 18;
fs->total_secs = 2880;
fs->media_bay = mediabay;
+ init_waitqueue_head(&fs->wait);
fs->dma_cmd = (struct dbdma_cmd *) DBDMA_ALIGN(fs->dbdma_cmd_space);
memset(fs->dma_cmd, 0, 2 * sizeof(struct dbdma_cmd));
xd_release, /* release */
block_fsync /* fsync */
};
-static struct wait_queue *xd_wait_int = NULL, *xd_wait_open = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(xd_wait_int);
+static DECLARE_WAIT_QUEUE_HEAD(xd_wait_open);
static u_char xd_valid[XD_MAXDRIVES] = { 0,0 };
static u_char xd_drives = 0, xd_irq = 5, xd_dma = 3, xd_maxsectors;
static u_char xd_override __initdata = 0, xd_type = 0;
static int xd_geo[XD_MAXDRIVES*3] __initdata = { 0,0,0,0,0,0 };
static volatile int xdc_busy = 0;
-static struct wait_queue *xdc_wait = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(xdc_wait);
typedef void (*timeout_fn)(unsigned long);
static struct timer_list xd_timer = { NULL, NULL, 0, 0, (timeout_fn) xd_wakeup },
inc_parport_count();
port->ops->inc_use_count();
- init_waitqueue(&tmp->wait_q);
+ init_waitqueue_head(&tmp->wait_q);
tmp->timeslice = PARPORT_DEFAULT_TIMESLICE;
tmp->waitnext = tmp->waitprev = NULL;
return -(ENOMEM);
}
memset((char *) op, 0, sizeof(struct audio_operations));
- init_waitqueue(&op->in_sleeper);
- init_waitqueue(&op->out_sleeper);
- init_waitqueue(&op->poll_sleeper);
+ init_waitqueue_head(&op->in_sleeper);
+ init_waitqueue_head(&op->out_sleeper);
+ init_waitqueue_head(&op->poll_sleeper);
if (driver_size < sizeof(struct audio_driver))
memset((char *) d, 0, sizeof(struct audio_driver));
* Bit 1 is set: a frame is playing
*/
int playing;
- struct wait_queue *write_queue, *open_queue, *sync_queue;
+ wait_queue_head_t write_queue, open_queue, sync_queue;
int open_mode;
int busy, syncing;
#ifdef CONFIG_ATARI
if (sq_unit < 0)
return;
- sq.write_queue = sq.open_queue = sq.sync_queue = 0;
+ init_waitqueue_head(&sq.write_queue);
+ init_waitqueue_head(&sq.open_queue);
+ init_waitqueue_head(&sq.sync_queue);
sq.busy = 0;
/* whatever you like as startup mode for /dev/dsp,
spinlock_t lock;
struct semaphore open_sem;
mode_t open_mode;
- struct wait_queue *open_wait;
+ wait_queue_head_t open_wait;
struct dmabuf {
void *rawbuf;
unsigned total_bytes;
int count;
unsigned error; /* over/underrun */
- struct wait_queue *wait;
+ wait_queue_head_t wait;
/* redundant, but makes calculations easier */
unsigned fragsize;
unsigned dmasize;
struct {
unsigned ird, iwr, icnt;
unsigned ord, owr, ocnt;
- struct wait_queue *iwait;
- struct wait_queue *owait;
+ wait_queue_head_t iwait;
+ wait_queue_head_t owait;
unsigned char ibuf[MIDIINBUF];
unsigned char obuf[MIDIOUTBUF];
} midi;
static int drain_dac1(struct es1370_state *s, int nonblock)
{
- struct wait_queue wait = { current, NULL };
+ DECLARE_WAITQUEUE(wait, current);
unsigned long flags;
int count, tmo;
static int drain_dac2(struct es1370_state *s, int nonblock)
{
- struct wait_queue wait = { current, NULL };
+ DECLARE_WAITQUEUE(wait, current);
unsigned long flags;
int count, tmo;
static int es1370_midi_release(struct inode *inode, struct file *file)
{
struct es1370_state *s = (struct es1370_state *)file->private_data;
- struct wait_queue wait = { current, NULL };
+ DECLARE_WAITQUEUE(wait, current);
unsigned long flags;
unsigned count, tmo;
continue;
}
memset(s, 0, sizeof(struct es1370_state));
- init_waitqueue(&s->dma_adc.wait);
- init_waitqueue(&s->dma_dac1.wait);
- init_waitqueue(&s->dma_dac2.wait);
- init_waitqueue(&s->open_wait);
- init_waitqueue(&s->midi.iwait);
- init_waitqueue(&s->midi.owait);
+ init_waitqueue_head(&s->dma_adc.wait);
+ init_waitqueue_head(&s->dma_dac1.wait);
+ init_waitqueue_head(&s->dma_dac2.wait);
+ init_waitqueue_head(&s->open_wait);
+ init_waitqueue_head(&s->midi.iwait);
+ init_waitqueue_head(&s->midi.owait);
s->open_sem = MUTEX;
s->magic = ES1370_MAGIC;
s->io = pcidev->base_address[0] & PCI_BASE_ADDRESS_IO_MASK;
spinlock_t lock;
struct semaphore open_sem;
mode_t open_mode;
- struct wait_queue *open_wait;
+ wait_queue_head_t open_wait;
struct dmabuf {
void *rawbuf;
unsigned total_bytes;
int count;
unsigned error; /* over/underrun */
- struct wait_queue *wait;
+ wait_queue_head_t wait;
/* redundant, but makes calculations easier */
unsigned fragsize;
unsigned dmasize;
struct {
unsigned ird, iwr, icnt;
unsigned ord, owr, ocnt;
- struct wait_queue *iwait;
- struct wait_queue *owait;
+ wait_queue_head_t iwait;
+ wait_queue_head_t owait;
unsigned char ibuf[MIDIINBUF];
unsigned char obuf[MIDIOUTBUF];
} midi;
static int drain_dac1(struct es1371_state *s, int nonblock)
{
- struct wait_queue wait = { current, NULL };
+ DECLARE_WAITQUEUE(wait, current);
unsigned long flags;
int count, tmo;
static int drain_dac2(struct es1371_state *s, int nonblock)
{
- struct wait_queue wait = { current, NULL };
+ DECLARE_WAITQUEUE(wait, current);
unsigned long flags;
int count, tmo;
static int es1371_midi_release(struct inode *inode, struct file *file)
{
struct es1371_state *s = (struct es1371_state *)file->private_data;
- struct wait_queue wait = { current, NULL };
+ DECLARE_WAITQUEUE(wait, current);
unsigned long flags;
unsigned count, tmo;
continue;
}
memset(s, 0, sizeof(struct es1371_state));
- init_waitqueue(&s->dma_adc.wait);
- init_waitqueue(&s->dma_dac1.wait);
- init_waitqueue(&s->dma_dac2.wait);
- init_waitqueue(&s->open_wait);
- init_waitqueue(&s->midi.iwait);
- init_waitqueue(&s->midi.owait);
+ init_waitqueue_head(&s->dma_adc.wait);
+ init_waitqueue_head(&s->dma_dac1.wait);
+ init_waitqueue_head(&s->dma_dac2.wait);
+ init_waitqueue_head(&s->open_wait);
+ init_waitqueue_head(&s->midi.iwait);
+ init_waitqueue_head(&s->midi.owait);
s->open_sem = MUTEX;
s->magic = ES1371_MAGIC;
s->io = pcidev->base_address[0] & PCI_BASE_ADDRESS_IO_MASK;
static int gus_audio_bsize;
static char bounce_buf[8 * 1024]; /* Must match value set to max_fragment */
-static struct wait_queue *dram_sleeper = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(dram_sleeper);
/*
* Variables and buffers for PCM output
gus_no_dma = 0;
}
- init_waitqueue(&dram_sleeper);
+ init_waitqueue_head(&dram_sleeper);
gus_busy = 1;
active_device = GUS_DEV_WAVE;
#define MAX_QUEUE_SIZE 4000
-static struct wait_queue *midi_sleeper[MAX_MIDI_DEV] = {NULL};
-static struct wait_queue *input_sleeper[MAX_MIDI_DEV] = {NULL};
+static wait_queue_head_t midi_sleeper[MAX_MIDI_DEV];
+static wait_queue_head_t input_sleeper[MAX_MIDI_DEV];
struct midi_buf
{
midi_out_buf[dev]->len = midi_out_buf[dev]->head = midi_out_buf[dev]->tail = 0;
open_devs++;
- init_waitqueue(&midi_sleeper[dev]);
- init_waitqueue(&input_sleeper[dev]);
+ init_waitqueue_head(&midi_sleeper[dev]);
+ init_waitqueue_head(&input_sleeper[dev]);
if (open_devs < 2) /* This was first open */
{
if (digital)
set_bit(F_HAVEDIGITAL, &dev.flags);
#endif
- init_waitqueue(&dev.writeblock);
- init_waitqueue(&dev.readblock);
- init_waitqueue(&dev.writeflush);
+ init_waitqueue_head(&dev.writeblock);
+ init_waitqueue_head(&dev.readblock);
+ init_waitqueue_head(&dev.writeflush);
msnd_fifo_init(&dev.DAPF);
msnd_fifo_init(&dev.DARF);
#ifndef LINUX20
#define SEQ_2 2
static int seq_mode = SEQ_1;
-static struct wait_queue *seq_sleeper = NULL;
-static struct wait_queue *midi_sleeper = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(seq_sleeper);
+static DECLARE_WAIT_QUEUE_HEAD(midi_sleeper);
static int midi_opened[MAX_MIDI_DEV] = {
0
if (seq_mode == SEQ_2)
tmr->open(tmr_no, seq_mode);
- init_waitqueue(&seq_sleeper);
- init_waitqueue(&midi_sleeper);
+ init_waitqueue_head(&seq_sleeper);
+ init_waitqueue_head(&midi_sleeper);
output_threshold = SEQ_MAX_QUEUE / 2;
return 0;
spinlock_t lock;
struct semaphore open_sem;
mode_t open_mode;
- struct wait_queue *open_wait;
+ wait_queue_head_t open_wait;
struct dmabuf {
void *rawbuf;
unsigned total_bytes;
int count;
unsigned error; /* over/underrun */
- struct wait_queue *wait;
+ wait_queue_head_t wait;
/* redundant, but makes calculations easier */
unsigned fragsize;
unsigned dmasize;
struct {
unsigned ird, iwr, icnt;
unsigned ord, owr, ocnt;
- struct wait_queue *iwait;
- struct wait_queue *owait;
+ wait_queue_head_t iwait;
+ wait_queue_head_t owait;
struct timer_list timer;
unsigned char ibuf[MIDIINBUF];
unsigned char obuf[MIDIOUTBUF];
static int drain_dac(struct sv_state *s, int nonblock)
{
- struct wait_queue wait = { current, NULL };
+ DECLARE_WAITQUEUE(wait, current);
unsigned long flags;
int count, tmo;
static int sv_midi_release(struct inode *inode, struct file *file)
{
struct sv_state *s = (struct sv_state *)file->private_data;
- struct wait_queue wait = { current, NULL };
+ DECLARE_WAITQUEUE(wait, current);
unsigned long flags;
unsigned count, tmo;
continue;
}
memset(s, 0, sizeof(struct sv_state));
- init_waitqueue(&s->dma_adc.wait);
- init_waitqueue(&s->dma_dac.wait);
- init_waitqueue(&s->open_wait);
- init_waitqueue(&s->midi.iwait);
- init_waitqueue(&s->midi.owait);
+ init_waitqueue_head(&s->dma_adc.wait);
+ init_waitqueue_head(&s->dma_dac.wait);
+ init_waitqueue_head(&s->open_wait);
+ init_waitqueue_head(&s->midi.iwait);
+ init_waitqueue_head(&s->midi.owait);
s->open_sem = MUTEX;
s->magic = SV_MAGIC;
s->iosb = pcidev->base_address[0] & PCI_BASE_ADDRESS_IO_MASK;
int samples_used; /* how many */
char interrupts_on; /* h/w MPU interrupts enabled ? */
char rom_samples_rdonly; /* can we write on ROM samples */
- struct wait_queue *interrupt_sleeper;
+ wait_queue_head_t interrupt_sleeper;
} dev;
static int detect_wffx(void);
}
- init_waitqueue (&dev.interrupt_sleeper);
+ init_waitqueue_head (&dev.interrupt_sleeper);
if (wavefront_hw_reset ()) {
printk (KERN_WARNING LOGNAME "hardware reset failed\n");
extern struct usb_operations uhci_device_operations;
/* Wakes up khubd */
-static struct wait_queue *usb_hub_wait = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(usb_hub_wait);
static spinlock_t hub_event_lock = SPIN_LOCK_UNLOCKED;
/* List of hubs needing servicing */
int present; /* this mouse is plugged in */
int active; /* someone is has this mouse's device open */
int ready; /* the mouse has changed state since the last read */
- struct wait_queue *wait; /* for polling */
+ wait_queue_head_t wait; /* for polling */
struct fasync_struct *fasync;
/* later, add a list here to support multiple mice */
/* but we will also need a list of file pointers to identify it */
};
-static struct mouse_state static_mouse_state;
+static struct mouse_state static_mouse_state = {
+ 0, 0, 0, 0,
+ 0, 0, 0,
+ __WAIT_QUEUE_HEAD_INITIALIZER(static_mouse_state.wait),
+};
spinlock_t usb_mouse_lock = SPIN_LOCK_UNLOCKED;
-static struct wait_queue *control_wakeup;
-static struct wait_queue *root_hub = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(control_wakeup);
+static DECLARE_WAIT_QUEUE_HEAD(root_hub);
static __u8 cc_to_status[16] = { /* mapping of the OHCI CC to the UHCI status codes; first guess */
/* Activ, Stalled, Data Buffer Err, Babble Detected : NAK recvd, CRC/Timeout, Bitstuff, reservd */
static int sohci_control_msg(struct usb_device *usb_dev, unsigned int pipe, void *cmd, void *data, int len)
{
- struct wait_queue wait = { current, NULL };
+ DECLARE_WAITQUEUE(wait, current);
struct ohci * ohci = usb_dev->bus->hcpriv;
int status;
union ep_addr_ ep_addr;
static int apm_resume = 0;
#endif
-static struct wait_queue *ohci_configure = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(ohci_configure);
#ifdef OHCI_TIMER
static struct timer_list ohci_timer; /* timer for root hub polling */
/*
* Control thread operations:
*/
-static struct wait_queue *control_wakeup;
+static DECLARE_WAIT_QUEUE_HEAD(control_wakeup);
/*
* This is the handler that gets called when a control transaction
*/
struct ohci_ed *control_ed = &dev->ohci->root_hub->ed[ED_CONTROL];
struct ohci_td *setup_td, *data_td, *status_td;
- struct wait_queue wait = { current, NULL };
+ DECLARE_WAITQUEUE(wait, current);
#if 0
printk(KERN_DEBUG "entering ohci_control_msg %p (ohci_dev: %p) pipe 0x%x, cmd %p, data %p, len %d\n", usb, dev, pipe, cmd, data, len);
#define compile_assert(x) do { switch (0) { case 1: case !(x): } } while (0)
-static struct wait_queue *uhci_configure = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(uhci_configure);
/*
* Return the result of a TD..
* We need to remove the TD from the lists (both interrupt
* list and TD lists) by hand if something bad happens!
*/
-static struct wait_queue *control_wakeup;
+static DECLARE_WAIT_QUEUE_HEAD(control_wakeup);
static int uhci_control_completed(int status, void *buffer, void *dev_id)
{
/* td points to the last td in the list, which interrupts on completion */
static int uhci_run_control(struct uhci_device *dev, struct uhci_td *first, struct uhci_td *last)
{
- struct wait_queue wait = { current, NULL };
+ DECLARE_WAITQUEUE(wait, current);
struct uhci_qh *ctrl_qh = uhci_qh_allocate(dev);
struct uhci_td *curtd;
inode->i_op = &coda_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &coda_symlink_inode_operations;
- else if (S_ISCHR(inode->i_mode)) {
- inode->i_op = &chrdev_inode_operations;
- inode->i_rdev = to_kdev_t(attr->va_rdev);
- } else if (S_ISBLK(inode->i_mode)) {
- inode->i_op = &blkdev_inode_operations;
- inode->i_rdev = to_kdev_t(attr->va_rdev);
- } else if (S_ISFIFO(inode->i_mode))
- init_fifo(inode);
- else if (S_ISSOCK(inode->i_mode))
- inode->i_op = NULL;
- else {
- printk ("coda_fill_inode: what's this? i_mode = %o\n",
- inode->i_mode);
- inode->i_op = NULL;
- }
+ else
+ init_special_inode(inode, inode->i_mode, attr->va_rdev);
}
/* this is effectively coda_iget:
static inline unsigned long coda_waitfor_upcall(struct upc_req *vmp)
{
- struct wait_queue wait = { current, NULL };
+ DECLARE_WAITQUEUE(wait, current);
unsigned long posttime;
vmp->uc_posttime = jiffies;
req->uc_outSize = *outSize ? *outSize : inSize;
req->uc_opcode = ((union inputArgs *)buffer)->ih.opcode;
req->uc_unique = ++vcommp->vc_seq;
- req->uc_sleep = NULL;
+ init_waitqueue_head(&req->uc_sleep);
/* Fill in the common input args. */
((union inputArgs *)buffer)->ih.unique = req->uc_unique;
sprintf(buffer, "%s(%d,%d)", name, MAJOR(dev), MINOR(dev));
return buffer;
}
+
+void init_special_inode(struct inode *inode, umode_t mode, int rdev)
+{
+ inode->i_mode = mode;
+ inode->i_op = NULL;
+ if (S_ISCHR(mode)) {
+ inode->i_op = &chrdev_inode_operations;
+ inode->i_rdev = to_kdev_t(rdev);
+ } else if (S_ISBLK(mode)) {
+ inode->i_op = &blkdev_inode_operations;
+ inode->i_rdev = to_kdev_t(rdev);
+ } else if (S_ISFIFO(mode))
+ init_fifo(inode);
+ else if (S_ISSOCK(mode))
+ ;
+ else
+ printk(KERN_DEBUG "init_special_inode: bogus imode (%o)\n", mode);
+}
if (inode->u.ext2_i.i_prealloc_count)
ext2_error (inode->i_sb, "ext2_read_inode",
"New inode has non-zero prealloc count!");
- if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
- inode->i_rdev = to_kdev_t(le32_to_cpu(raw_inode->i_block[0]));
- else if (S_ISLNK(inode->i_mode) && !inode->i_blocks)
+ if (S_ISLNK(inode->i_mode) && !inode->i_blocks)
for (block = 0; block < EXT2_N_BLOCKS; block++)
inode->u.ext2_i.i_data[block] = raw_inode->i_block[block];
else for (block = 0; block < EXT2_N_BLOCKS; block++)
inode->u.ext2_i.i_data[block] = le32_to_cpu(raw_inode->i_block[block]);
- brelse (bh);
- inode->i_op = NULL;
if (inode->i_ino == EXT2_ACL_IDX_INO ||
inode->i_ino == EXT2_ACL_DATA_INO)
/* Nothing to do */ ;
inode->i_op = &ext2_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &ext2_symlink_inode_operations;
- else if (S_ISCHR(inode->i_mode))
- inode->i_op = &chrdev_inode_operations;
- else if (S_ISBLK(inode->i_mode))
- inode->i_op = &blkdev_inode_operations;
- else if (S_ISFIFO(inode->i_mode))
- init_fifo(inode);
+ else
+ init_special_inode(inode, inode->i_mode,
+ le32_to_cpu(raw_inode->i_block[0]));
+ brelse (bh);
inode->i_attr_flags = 0;
if (inode->u.ext2_i.i_flags & EXT2_SYNC_FL) {
inode->i_attr_flags |= ATTR_FLAG_SYNCRONOUS;
return -ENOENT;
}
+static inline void ext2_set_de_type(struct super_block *sb,
+ struct ext2_dir_entry_2 *de,
+ umode_t mode) {
+ if (!EXT2_HAS_INCOMPAT_FEATURE(sb, EXT2_FEATURE_INCOMPAT_FILETYPE))
+ return;
+ if (S_ISCHR(mode))
+ de->file_type = EXT2_FT_CHRDEV;
+ else if (S_ISBLK(mode))
+ de->file_type = EXT2_FT_BLKDEV;
+ else if (S_ISFIFO(mode))
+ de->file_type = EXT2_FT_FIFO;
+ else if (S_ISLNK(mode))
+ de->file_type = EXT2_FT_SYMLINK;
+ else if (S_ISREG(mode))
+ de->file_type = EXT2_FT_REG_FILE;
+ else if (S_ISDIR(mode))
+ de->file_type = EXT2_FT_DIR;
+}
+
/*
* By the time this is called, we already have created
* the directory cache entry for the new file, but it
return err;
}
de->inode = cpu_to_le32(inode->i_ino);
- if (EXT2_HAS_INCOMPAT_FEATURE(dir->i_sb,
- EXT2_FEATURE_INCOMPAT_FILETYPE))
- de->file_type = EXT2_FT_REG_FILE;
+ ext2_set_de_type(dir->i_sb, de, S_IFREG);
dir->i_version = ++event;
mark_buffer_dirty(bh, 1);
if (IS_SYNC(dir)) {
goto out;
inode->i_uid = current->fsuid;
- inode->i_mode = mode;
- inode->i_op = NULL;
+ init_special_inode(inode, mode, rdev);
bh = ext2_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
if (!bh)
goto out_no_entry;
de->inode = cpu_to_le32(inode->i_ino);
dir->i_version = ++event;
- if (S_ISREG(inode->i_mode)) {
- inode->i_op = &ext2_file_inode_operations;
- if (EXT2_HAS_INCOMPAT_FEATURE(dir->i_sb,
- EXT2_FEATURE_INCOMPAT_FILETYPE))
- de->file_type = EXT2_FT_REG_FILE;
- } else if (S_ISCHR(inode->i_mode)) {
- inode->i_op = &chrdev_inode_operations;
- if (EXT2_HAS_INCOMPAT_FEATURE(dir->i_sb,
- EXT2_FEATURE_INCOMPAT_FILETYPE))
- de->file_type = EXT2_FT_CHRDEV;
- } else if (S_ISBLK(inode->i_mode)) {
- inode->i_op = &blkdev_inode_operations;
- if (EXT2_HAS_INCOMPAT_FEATURE(dir->i_sb,
- EXT2_FEATURE_INCOMPAT_FILETYPE))
- de->file_type = EXT2_FT_BLKDEV;
- } else if (S_ISFIFO(inode->i_mode)) {
- init_fifo(inode);
- if (EXT2_HAS_INCOMPAT_FEATURE(dir->i_sb,
- EXT2_FEATURE_INCOMPAT_FILETYPE))
- de->file_type = EXT2_FT_FIFO;
- }
- if (S_ISBLK(mode) || S_ISCHR(mode))
- inode->i_rdev = to_kdev_t(rdev);
+ ext2_set_de_type(dir->i_sb, de, inode->i_mode);
mark_inode_dirty(inode);
mark_buffer_dirty(bh, 1);
if (IS_SYNC(dir)) {
de->name_len = 1;
de->rec_len = cpu_to_le16(EXT2_DIR_REC_LEN(de->name_len));
strcpy (de->name, ".");
- if (EXT2_HAS_INCOMPAT_FEATURE(dir->i_sb,
- EXT2_FEATURE_INCOMPAT_FILETYPE))
- de->file_type = EXT2_FT_DIR;
+ ext2_set_de_type(dir->i_sb, de, S_IFDIR);
de = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
de->inode = cpu_to_le32(dir->i_ino);
de->rec_len = cpu_to_le16(inode->i_sb->s_blocksize - EXT2_DIR_REC_LEN(1));
de->name_len = 2;
strcpy (de->name, "..");
- if (EXT2_HAS_INCOMPAT_FEATURE(dir->i_sb,
- EXT2_FEATURE_INCOMPAT_FILETYPE))
- de->file_type = EXT2_FT_DIR;
+ ext2_set_de_type(dir->i_sb, de, S_IFDIR);
inode->i_nlink = 2;
mark_buffer_dirty(dir_block, 1);
brelse (dir_block);
if (!bh)
goto out_no_entry;
de->inode = cpu_to_le32(inode->i_ino);
- if (EXT2_HAS_INCOMPAT_FEATURE(dir->i_sb,
- EXT2_FEATURE_INCOMPAT_FILETYPE))
- de->file_type = EXT2_FT_DIR;
+ ext2_set_de_type(dir->i_sb, de, S_IFDIR);
dir->i_version = ++event;
mark_buffer_dirty(bh, 1);
if (IS_SYNC(dir)) {
if (!bh)
goto out_no_entry;
de->inode = cpu_to_le32(inode->i_ino);
- if (EXT2_HAS_INCOMPAT_FEATURE(dir->i_sb,
- EXT2_FEATURE_INCOMPAT_FILETYPE))
- de->file_type = EXT2_FT_SYMLINK;
+ ext2_set_de_type(dir->i_sb, de, S_IFLNK);
dir->i_version = ++event;
mark_buffer_dirty(bh, 1);
if (IS_SYNC(dir)) {
return err;
de->inode = cpu_to_le32(inode->i_ino);
- if (EXT2_HAS_INCOMPAT_FEATURE(inode->i_sb,
- EXT2_FEATURE_INCOMPAT_FILETYPE)) {
- if (S_ISREG(inode->i_mode))
- de->file_type = EXT2_FT_REG_FILE;
- else if (S_ISDIR(inode->i_mode))
- de->file_type = EXT2_FT_DIR;
- else if (S_ISLNK(inode->i_mode))
- de->file_type = EXT2_FT_SYMLINK;
- else if (S_ISCHR(inode->i_mode))
- de->file_type = EXT2_FT_CHRDEV;
- else if (S_ISBLK(inode->i_mode))
- de->file_type = EXT2_FT_BLKDEV;
- else if (S_ISFIFO(inode->i_mode))
- de->file_type = EXT2_FT_FIFO;
- }
+ ext2_set_de_type(dir->i_sb, de, inode->i_mode);
dir->i_version = ++event;
mark_buffer_dirty(bh, 1);
if (IS_SYNC(dir)) {
/* File creation lock. This is system-wide to avoid deadlocks in rename. */
/* (rename might deadlock before detecting cross-FS moves.) */
-static struct wait_queue *creation_wait = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(creation_wait);
static int creation_lock = 0;
return 0;
}
-/*
- * hfs_mknod()
- *
- * This is the mknod() entry in the inode_operations structure for
- * regular HFS directories. The purpose is to create a new entry
- * in a directory, given the inode for the parent directory and the
- * name (and its length) and the mode of the new entry (and the device
- * number if the entry is to be a device special file).
- *
- * HFS only supports regular files and directories and Linux disallows
- * using mknod() to create directories. Thus we just check the arguments
- * and call hfs_create().
- */
-int hfs_mknod(struct inode *dir, struct dentry *dentry, int mode, int rdev)
-{
- if (!dir)
- return -ENOENT;
-
- /* the only thing we currently do. */
- if (S_ISREG(mode))
- return hfs_create(dir, dentry, mode);
-
- return -EPERM;
-}
-
/*
* hfs_unlink()
*
NULL, /* symlink */
hfs_mkdir, /* mkdir */
hfs_rmdir, /* rmdir */
- hfs_mknod, /* mknod */
+ NULL, /* mknod */
hfs_rename, /* rename */
NULL, /* readlink */
NULL, /* follow_link */
static int dbl_readdir(struct file *, void *, filldir_t);
static int dbl_create(struct inode *, struct dentry *, int);
static int dbl_mkdir(struct inode *, struct dentry *, int);
-static int dbl_mknod(struct inode *, struct dentry *, int, int);
static int dbl_unlink(struct inode *, struct dentry *);
static int dbl_rmdir(struct inode *, struct dentry *);
static int dbl_rename(struct inode *, struct dentry *,
NULL, /* symlink */
dbl_mkdir, /* mkdir */
dbl_rmdir, /* rmdir */
- dbl_mknod, /* mknod */
+ NULL, /* mknod */
dbl_rename, /* rename */
NULL, /* readlink */
NULL, /* follow_link */
return error;
}
-/*
- * dbl_mknod()
- *
- * This is the mknod() entry in the inode_operations structure for
- * regular HFS directories. The purpose is to create a new entry
- * in a directory, given the inode for the parent directory and the
- * name (and its length) and the mode of the new entry (and the device
- * number if the entry is to be a device special file).
- */
-static int dbl_mknod(struct inode *dir, struct dentry *dentry,
- int mode, int rdev)
-{
- int error;
-
- if (is_hdr(dir, dentry->d_name.name, dentry->d_name.len)) {
- error = -EEXIST;
- } else {
- error = hfs_mknod(dir, dentry, mode, rdev);
- }
- return error;
-}
-
/*
* dbl_unlink()
*
NULL, /* symlink */
hfs_mkdir, /* mkdir */
nat_rmdir, /* rmdir */
- hfs_mknod, /* mknod */
+ NULL, /* mknod */
hfs_rename, /* rename */
NULL, /* readlink */
NULL, /* follow_link */
inode->i_op = &isofs_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &isofs_symlink_inode_operations;
- else if (S_ISCHR(inode->i_mode))
- inode->i_op = &chrdev_inode_operations;
- else if (S_ISBLK(inode->i_mode))
- inode->i_op = &blkdev_inode_operations;
- else if (S_ISFIFO(inode->i_mode))
- init_fifo(inode);
+ else
+ /* XXX - parse_rock_ridge_inode() had already set i_rdev. */
+ init_special_inode(inode, inode->i_mode, kdev_t_to_nr(inode->i_rdev));
}
return;
inode->i_size = raw_inode->i_size;
inode->i_mtime = inode->i_atime = inode->i_ctime = raw_inode->i_time;
inode->i_blocks = inode->i_blksize = 0;
- if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
- inode->i_rdev = to_kdev_t(raw_inode->i_zone[0]);
- else for (block = 0; block < 9; block++)
+ for (block = 0; block < 9; block++)
inode->u.minix_i.u.i1_data[block] = raw_inode->i_zone[block];
- brelse(bh);
if (S_ISREG(inode->i_mode))
inode->i_op = &minix_file_inode_operations;
else if (S_ISDIR(inode->i_mode))
inode->i_op = &minix_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &minix_symlink_inode_operations;
- else if (S_ISCHR(inode->i_mode))
- inode->i_op = &chrdev_inode_operations;
- else if (S_ISBLK(inode->i_mode))
- inode->i_op = &blkdev_inode_operations;
- else if (S_ISFIFO(inode->i_mode))
- init_fifo(inode);
+ else
+ init_special_inode(inode, inode->i_mode, raw_inode->i_zone[0]);
+ brelse(bh);
}
/*
inode->i_atime = raw_inode->i_atime;
inode->i_ctime = raw_inode->i_ctime;
inode->i_blocks = inode->i_blksize = 0;
- if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
- inode->i_rdev = to_kdev_t(raw_inode->i_zone[0]);
- else for (block = 0; block < 10; block++)
+ for (block = 0; block < 10; block++)
inode->u.minix_i.u.i2_data[block] = raw_inode->i_zone[block];
- brelse(bh);
if (S_ISREG(inode->i_mode))
inode->i_op = &minix_file_inode_operations;
else if (S_ISDIR(inode->i_mode))
inode->i_op = &minix_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &minix_symlink_inode_operations;
- else if (S_ISCHR(inode->i_mode))
- inode->i_op = &chrdev_inode_operations;
- else if (S_ISBLK(inode->i_mode))
- inode->i_op = &blkdev_inode_operations;
- else if (S_ISFIFO(inode->i_mode))
- init_fifo(inode);
+ else
+ init_special_inode(inode, inode->i_mode, raw_inode->i_zone[0]);
+ brelse(bh);
}
/*
if (!inode)
return -ENOSPC;
inode->i_uid = current->fsuid;
- inode->i_mode = mode;
- inode->i_op = NULL;
- if (S_ISREG(inode->i_mode))
- inode->i_op = &minix_file_inode_operations;
- else if (S_ISCHR(inode->i_mode))
- inode->i_op = &chrdev_inode_operations;
- else if (S_ISBLK(inode->i_mode))
- inode->i_op = &blkdev_inode_operations;
- else if (S_ISFIFO(inode->i_mode))
- init_fifo(inode);
- if (S_ISBLK(mode) || S_ISCHR(mode))
- inode->i_rdev = to_kdev_t(rdev);
+ init_special_inode(inode, mode, rdev);
mark_inode_dirty(inode);
error = minix_add_entry(dir, dentry->d_name.name, dentry->d_name.len, &bh, &de);
if (error) {
return retval;
}
+int vfs_create(struct inode *dir, struct dentry *dentry, int mode)
+{
+ int error;
+
+ error = may_create(dir, dentry);
+ if (error)
+ goto exit_lock;
+
+ error = -EACCES; /* shouldn't it be ENOSYS? */
+ if (!dir->i_op || !dir->i_op->create)
+ goto exit_lock;
+
+ DQUOT_INIT(dir);
+ error = dir->i_op->create(dir, dentry, mode);
+exit_lock:
+ return error;
+}
+
/*
* open_namei()
*
error = 0;
if (flag & O_EXCL)
error = -EEXIST;
- } else if ((error = may_create(dir->d_inode, dentry)) == 0) {
- if (!dir->d_inode->i_op || !dir->d_inode->i_op->create)
- error = -EACCES;
- else {
- DQUOT_INIT(dir->d_inode);
- error = dir->d_inode->i_op->create(dir->d_inode, dentry, mode);
- /* Don't check for write permission, don't truncate */
- acc_mode = 0;
- flag &= ~O_TRUNC;
- }
+ } else {
+ error = vfs_create(dir->d_inode, dentry,mode);
+ /* Don't check for write permission, don't truncate */
+ acc_mode = 0;
+ flag &= ~O_TRUNC;
}
unlock_dir(dir);
if (error)
{
int error;
char * tmp;
+ struct dentry * dentry;
lock_kernel();
error = -EPERM;
if (S_ISDIR(mode) || (!S_ISFIFO(mode) && !capable(CAP_SYS_ADMIN)))
goto out;
+ tmp = getname(filename);
+ error = PTR_ERR(tmp);
+ if (IS_ERR(tmp))
+ goto out;
+
error = -EINVAL;
switch (mode & S_IFMT) {
case 0:
- mode |= S_IFREG;
- break;
- case S_IFREG: case S_IFCHR: case S_IFBLK: case S_IFIFO: case S_IFSOCK:
+ mode |= S_IFREG; /* fallthrough */
+ case S_IFREG:
+ mode &= ~current->fs->umask;
+ dentry = lookup_dentry(filename, NULL, LOOKUP_FOLLOW);
+ if (IS_ERR(dentry))
+ error = PTR_ERR(dentry);
+ else {
+ struct dentry *dir = lock_parent(dentry);
+ error = -ENOENT;
+ if (check_parent(dir, dentry))
+ error = vfs_create(dir->d_inode, dentry, mode);
+ dput(dentry);
+ }
break;
- default:
- goto out;
- }
- tmp = getname(filename);
- error = PTR_ERR(tmp);
- if (!IS_ERR(tmp)) {
- struct dentry * dentry = do_mknod(tmp,mode,dev);
- putname(tmp);
+ case S_IFCHR: case S_IFBLK: case S_IFIFO: case S_IFSOCK:
+ dentry = do_mknod(tmp,mode,dev);
error = PTR_ERR(dentry);
if (!IS_ERR(dentry)) {
dput(dentry);
error = 0;
}
+ break;
}
+ putname(tmp);
+
out:
unlock_kernel();
return error;
static int c_last_returned_index;
static struct ncp_dirent *c_entry = NULL;
static int c_lock = 0;
-static struct wait_queue *c_wait = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(c_wait);
static int ncp_read_volume_list(struct ncp_server *, int, int,
struct ncp_dirent *);
inode->i_op = &nfs_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &nfs_symlink_inode_operations;
- else if (S_ISCHR(inode->i_mode)) {
- inode->i_op = &chrdev_inode_operations;
- inode->i_rdev = to_kdev_t(fattr->rdev);
- } else if (S_ISBLK(inode->i_mode)) {
- inode->i_op = &blkdev_inode_operations;
- inode->i_rdev = to_kdev_t(fattr->rdev);
- } else if (S_ISFIFO(inode->i_mode))
- init_fifo(inode);
else
- inode->i_op = NULL;
+ init_special_inode(inode, inode->i_mode, fattr->rdev);
/*
* Preset the size and mtime, as there's no need
* to invalidate the caches.
static int hash_lock = 0;
static int want_lock = 0;
static int hash_count = 0;
-static struct wait_queue * hash_wait = NULL;
+static DECLARE_WAIT_QUEUE_HEAD( hash_wait );
#define READLOCK 0
#define WRITELOCK 1
static char * buffer = NULL;
static int read_pos, write_pos;
static int clip_pos, max_pos;
-static struct wait_queue * read_wait = NULL;
-static struct wait_queue * write_wait = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(read_wait);
+static DECLARE_WAIT_QUEUE_HEAD(write_wait);
static /*inline*/ int reserve_write_space(int len)
{
memcpy(&inode->u.qnx4_i, (struct qnx4_inode_info *) raw_inode, QNX4_DIR_ENTRY_SIZE);
inode->i_op = &qnx4_file_inode_operations;
- if (S_ISREG(inode->i_mode)) {
+ if (S_ISREG(inode->i_mode))
inode->i_op = &qnx4_file_inode_operations;
- } else {
- if (S_ISDIR(inode->i_mode)) {
- inode->i_op = &qnx4_dir_inode_operations;
- } else {
- if (S_ISLNK(inode->i_mode)) {
- inode->i_op = &qnx4_symlink_inode_operations;
- } else {
- if (S_ISCHR(inode->i_mode)) {
- inode->i_op = &chrdev_inode_operations;
- } else {
- if (S_ISBLK(inode->i_mode)) {
- inode->i_op = &blkdev_inode_operations;
- } else {
- if (S_ISFIFO(inode->i_mode)) {
- init_fifo(inode);
- }
- }
- }
- }
- }
- }
+ else if (S_ISDIR(inode->i_mode))
+ inode->i_op = &qnx4_dir_inode_operations;
+ else if (S_ISLNK(inode->i_mode))
+ inode->i_op = &qnx4_symlink_inode_operations;
+ else
+ /* HUH??? Where is device number? Oh, well... */
+ init_special_inode(inode, inode->i_mode, 0);
+
brelse(bh);
}
_inode()'s job.
* ialloc.c: (sysv_free_inode):
Fixed race.
+
+Sun, 30 Apr 1999 AV
+ * namei.c (sysv_mknod):
+ Removed dead code (S_IFREG case is now passed to
+ ->create() by VFS).
}
inode->i_blocks = inode->i_blksize = 0;
if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
- inode->i_rdev = to_kdev_t(raw_inode->i_a.i_rdev);
+ ;
else
if (sb->sv_convert)
for (block = 0; block < 10+1+1+1; block++)
inode->i_op = &sysv_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &sysv_symlink_inode_operations;
- else if (S_ISCHR(inode->i_mode))
- inode->i_op = &chrdev_inode_operations;
- else if (S_ISBLK(inode->i_mode))
- inode->i_op = &blkdev_inode_operations;
- else if (S_ISFIFO(inode->i_mode))
- init_fifo(inode);
+ else
+ init_special_inode(inode, inode->i_mode,raw_inode->i_a.i_rdev);
}
/* To avoid inconsistencies between inodes in memory and inodes on disk. */
if (!inode)
return -ENOSPC;
inode->i_uid = current->fsuid;
- inode->i_mode = mode;
- inode->i_op = NULL;
- if (S_ISREG(inode->i_mode))
- inode->i_op = &sysv_file_inode_operations;
- else if (S_ISCHR(inode->i_mode))
- inode->i_op = &chrdev_inode_operations;
- else if (S_ISBLK(inode->i_mode))
- inode->i_op = &blkdev_inode_operations;
- else if (S_ISFIFO(inode->i_mode))
- init_fifo(inode);
- if (S_ISBLK(mode) || S_ISCHR(mode))
- inode->i_rdev = to_kdev_t(rdev);
+ init_special_inode(inode, mode, rdev);
mark_inode_dirty(inode);
error = sysv_add_entry(dir, dentry->d_name.name,
dentry->d_name.len, &bh, &de);
inode->u.ufs_i.i_lastfrag = howmany (inode->i_size, uspi->s_fsize);
if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
- inode->i_rdev = to_kdev_t(SWAB32(ufs_inode->ui_u2.ui_addr.ui_db[0]));
+ ;
else if (inode->i_blocks) {
for (i = 0; i < (UFS_NDADDR + UFS_NINDIR); i++)
inode->u.ufs_i.i_u1.i_data[i] = ufs_inode->ui_u2.ui_addr.ui_db[i];
inode->u.ufs_i.i_u1.i_symlink[i] = ufs_inode->ui_u2.ui_symlink[i];
}
- brelse (bh);
inode->i_op = NULL;
inode->i_op = &ufs_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &ufs_symlink_inode_operations;
- else if (S_ISCHR(inode->i_mode))
- inode->i_op = &chrdev_inode_operations;
- else if (S_ISBLK(inode->i_mode))
- inode->i_op = &blkdev_inode_operations;
- else if (S_ISFIFO(inode->i_mode))
- init_fifo(inode);
+ else
+ init_special_inode(inode, inode->i_mode,
+ SWAB32(ufs_inode->ui_u2.ui_addr.ui_db[0]));
+
+ brelse (bh);
#ifdef UFS_INODE_DEBUG_MORE
ufs_print_inode (inode);
goto out;
inode->i_uid = current->fsuid;
- inode->i_mode = mode;
- inode->i_op = NULL;
- if (S_ISREG(inode->i_mode))
- inode->i_op = &ufs_file_inode_operations;
- else if (S_ISCHR(inode->i_mode))
- inode->i_op = &chrdev_inode_operations;
- else if (S_ISBLK(inode->i_mode))
- inode->i_op = &blkdev_inode_operations;
- else if (S_ISFIFO(inode->i_mode))
- init_fifo(inode);
- if (S_ISBLK(mode) || S_ISCHR(mode))
- inode->i_rdev = to_kdev_t(rdev);
+ init_special_inode(inode, mode, rdev);
mark_inode_dirty(inode);
bh = ufs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
if (!bh)
umsdos_setup_dir(dentry);
} else if (S_ISLNK (inode->i_mode)) {
inode->i_op = &umsdos_symlink_inode_operations;
- } else if (S_ISCHR (inode->i_mode)) {
- inode->i_op = &chrdev_inode_operations;
- } else if (S_ISBLK (inode->i_mode)) {
- inode->i_op = &blkdev_inode_operations;
- } else if (S_ISFIFO (inode->i_mode)) {
- init_fifo (inode);
- }
+ } else
+ init_special_inode(inode, inode->i_mode,
+ kdev_t_to_nr(inode->i_rdev));
}
extern char * bdevname(kdev_t dev);
extern char * cdevname(kdev_t dev);
extern char * kdevname(kdev_t dev);
+extern void init_special_inode(struct inode *, umode_t, int);
extern void init_fifo(struct inode * inode);
loff_t *);
extern int hfs_create(struct inode *, struct dentry *, int);
extern int hfs_mkdir(struct inode *, struct dentry *, int);
-extern int hfs_mknod(struct inode *, struct dentry *, int, int);
extern int hfs_unlink(struct inode *, struct dentry *);
extern int hfs_rmdir(struct inode *, struct dentry *);
extern int hfs_rename(struct inode *, struct dentry *,
unsigned int runchars;
struct lp_stats stats;
#endif
- struct wait_queue *wait_q;
+ wait_queue_head_t wait_q;
unsigned int last_error;
volatile unsigned int irq_detected:1;
volatile unsigned int irq_missed:1;
EXPORT_SYMBOL(refile_buffer);
EXPORT_SYMBOL(nr_async_pages);
EXPORT_SYMBOL(___strtok);
+EXPORT_SYMBOL(init_special_inode);
EXPORT_SYMBOL(init_fifo);
EXPORT_SYMBOL(fifo_inode_operations);
EXPORT_SYMBOL(chrdev_inode_operations);
projects / history.git / commitdiff