gctINT gckDebugFileSystemCreateNode ( IN gctINT SizeInKB , IN gctCONST_STRING ParentName , IN gctCONST_STRING NodeName , OUT gcsDebugFileSystemNode **Node ) { gcsDebugFileSystemNode*node ; /* allocate space for our metadata and initialize it */ if ( ( node = kmalloc ( sizeof (gcsDebugFileSystemNode ) , GFP_KERNEL ) ) == NULL ) goto struct_malloc_failed ; /*Zero it out*/ memset ( node , 0 , sizeof (gcsDebugFileSystemNode ) ) ; /*Init the sync primitives*/ #if defined(DECLARE_WAIT_QUEUE_HEAD) init_waitqueue_head ( gcmkNODE_READQ ( node ) ) ; #else init_waitqueue ( gcmkNODE_READQ ( node ) ) ; #endif #if defined(DECLARE_WAIT_QUEUE_HEAD) init_waitqueue_head ( gcmkNODE_WRITEQ ( node ) ) ; #else init_waitqueue ( gcmkNODE_WRITEQ ( node ) ) ; #endif sema_init ( gcmkNODE_SEM ( node ) , 1 ) ; /*End the sync primitives*/ /* figure out how much of a buffer this should be and allocate the buffer */ node->size = 1024 * SizeInKB ; if ( ( node->data = ( char * ) vmalloc ( sizeof (char ) * node->size ) ) == NULL ) goto data_malloc_failed ; /*creating the debug file system*/ node->parent = debugfs_create_dir ( ParentName , NULL ) ; /*creating the file*/ node->filen = debugfs_create_file ( NodeName , S_IRUGO | S_IWUSR , node->parent , NULL , &debugfs_operations ) ; /* add it to our linked list */ node->next = gc_dbgfs.linkedlist ; gc_dbgfs.linkedlist = node ; /* pass the struct back */ *Node = node ; return 0 ; vfree ( node->data ) ; data_malloc_failed: kfree ( node ) ; struct_malloc_failed: return - ENOMEM ; }
/* * These are initializations that only need to be done * once, because the fields are idempotent across use * of the inode.. */ static inline void init_once(struct inode * inode) { memset(inode, 0, sizeof(*inode)); init_waitqueue(&inode->i_wait); INIT_LIST_HEAD(&inode->i_hash); INIT_LIST_HEAD(&inode->i_dentry); sema_init(&inode->i_sem, 1); sema_init(&inode->i_atomic_write, 1); }
static void afs_addevent(char *event) { int hashcode; afs_event_t *newp; AFS_ASSERT_GLOCK(); hashcode = afs_evhash(event); newp = osi_linux_alloc(sizeof(afs_event_t), 0); afs_evhashcnt++; newp->next = afs_evhasht[hashcode]; afs_evhasht[hashcode] = newp; #if defined(AFS_LINUX24_ENV) init_waitqueue_head(&newp->cond); #else init_waitqueue(&newp->cond); #endif newp->seq = 0; newp->event = &dummyV; /* Dummy address for new events */ newp->refcount = 0; }
/* * Open a Linux block device given its Linux device number. * The gendisk parameter need only be non-NULL if opening a partition; * it can be NULL when opening the entire disk ("partition 0"). */ oskit_error_t oskit_linux_block_open_kdev(int kdev, struct gendisk *gd, unsigned flags, oskit_blkio_t **out_io) { int err, i, mode; struct file file; struct peropen *po; struct task_struct ts; OSKIT_LINUX_CREATE_CURRENT(ts); if (flags & ~OSKIT_DEV_OPEN_ALL) { err = OSKIT_E_DEV_BADPARAM; goto finish; } switch (flags & (OSKIT_DEV_OPEN_READ|OSKIT_DEV_OPEN_WRITE)) { case OSKIT_DEV_OPEN_READ: mode = O_RDONLY; break; case OSKIT_DEV_OPEN_WRITE: mode = O_WRONLY; break; case OSKIT_DEV_OPEN_READ|OSKIT_DEV_OPEN_WRITE: mode = O_RDWR; break; default: err = OSKIT_E_DEV_BADPARAM; goto finish; } /* * Linux uses 1k blocks by default. * We WANT sector-sized blocks in all cases. */ if (!hardsect_size[MAJOR(kdev)]) { osenv_log(OSENV_LOG_DEBUG, "default sector size = 512b on %d,%d\n", MAJOR(kdev), MINOR(kdev)); blksize_size[MAJOR(kdev)][MINOR(kdev)] = 512; } else if (blksize_size[MAJOR(kdev)][MINOR(kdev)]!= hardsect_size[MAJOR(kdev)][MINOR(kdev)]) { osenv_log(OSENV_LOG_DEBUG, "setting block size to sector size on %d,%d\n", MAJOR(kdev), MINOR(kdev)); blksize_size[MAJOR(kdev)][MINOR(kdev)] = hardsect_size[MAJOR(kdev)][MINOR(kdev)]; /* this is a Linux limitation: */ if (hardsect_size[MAJOR(kdev)][MINOR(kdev)] < 512) { err = OSKIT_E_DEV_BADOP; /* XXX */ goto finish; } } /* * Search the open list. */ while (1) { for (po = open_list; po; po = po->next) if (po->inode.i_rdev == kdev && po->mode == mode) break; if (po) { if (po->busy) { po->want = 1; sleep_on(&po->waitq); continue; } po->count++; *out_io = &po->ioi; err = 0; goto finish; } break; } /* * Allocate and initialize a device structure. */ po = oskit_linux_mem_alloc(sizeof(struct peropen), OSENV_PHYS_WIRED, 0); if (!po) { err = OSKIT_E_OUTOFMEMORY; goto finish; } po->ioi.ops = &block_io_ops; po->fops = blkdevs[MAJOR(kdev)].fops; po->count = 1; po->busy = 1; po->want = 0; po->mode = mode; init_waitqueue(&po->waitq); po->inode.i_rdev = kdev; po->inode.i_emul_data = po; po->next = open_list; open_list = po->next; if (!po->fops->open) err = 0; else { struct dentry dentry; file.f_mode = mode; file.f_flags = 0; file.f_dentry = &dentry; dentry.d_inode = &po->inode; err = (*po->fops->open)(&po->inode, &file); } if (err) { open_list_remove(po); if (po->want) { po->want = 0; wake_up(&po->waitq); } err = linux_to_oskit_error(err); oskit_linux_mem_free(po, OSENV_PHYS_WIRED, sizeof(struct peropen)); } else { /* * Now that the device has been opened, * we can extract its size. This might * not have been set properly in blk_size * before the open call, e.g. for the floppy driver. */ if (gd) po->size = gd->part[MINOR(kdev)].nr_sects; else { osenv_assert(blk_size[MAJOR(kdev)] && blk_size[MAJOR(kdev)][MINOR(kdev)]); po->size = (blk_size[MAJOR(kdev)][MINOR(kdev)] << (BLOCK_SIZE_BITS - DISK_BLOCK_BITS)); } if (blksize_size[MAJOR(kdev)] && blksize_size[MAJOR(kdev)][MINOR(kdev)]) { int bshift = DISK_BLOCK_BITS; po->bsize = blksize_size[MAJOR(kdev)][MINOR(kdev)]; for (i = po->bsize >> DISK_BLOCK_BITS; i != 1; i >>= 1) bshift++; po->bshift = bshift; } else {
void flash_probe() { int i; /* start adresses for the Flash chips - these should really * be settable in some other way. */ #ifdef FLASH_VERBOSE safe_printk("Probing flash...\n"); #endif #ifdef CONFIG_COLDFIRE chips[0].start = (unsigned char *)(0xf0200000); #elif CONFIG_SED_SIOS chips[0].start = (unsigned char *)(0x01400000); chips[1].start = (unsigned char *)(0x01600000); #elif CONFIG_ARCH_NETARM chips[0].start = (unsigned char *)(0x10000000); #elif CONFIG_MWI chips[0].start = (unsigned char *)(0x000000); #else chips[0].start = (unsigned char *)(MEM_CSE0_START | MEM_NON_CACHEABLE); chips[1].start = (unsigned char *)(MEM_CSE1_START | MEM_NON_CACHEABLE); #endif for(i = 0; i < MAX_CHIPS; i++) { struct flashchip *chip = chips + i; flashptr flashStart = (flashptr)chip->start; #ifdef FLASH_8BITX4 unsigned long manu_long; #endif unsigned short manu; #ifdef FLASH_VERBOSE safe_printk("Probing flash #%d at 0x%p\n", i, flashStart); #endif #ifdef CONFIG_SVINTO_SIM /* in the simulator, dont trash the flash ram by writing unlocks */ chip->isValid = 1; chip->device_id = AM29LV160BT; #else /* reset */ flashStart[unlockAddress1] = unlockData1; flashStart[unlockAddress2] = unlockData2; flashStart[unlockAddress1] = resetData; /* read manufacturer */ flashStart[unlockAddress1] = unlockData1; flashStart[unlockAddress2] = unlockData2; flashStart[unlockAddress1] = manufacturerUnlockData; #ifdef FLASH_8BITX4 manu_long = flashStart[manufacturerAddress]; manu = manu_long & 0x000000ffU; #else manu = flashStart[manufacturerAddress]; #endif chip->isValid = (manu == ManufacturerAMD || manu == ManufacturerToshiba || manu == ManufacturerST || manu == ManufacturerSST); chip->manufacturer_id = manu; if(!chip->isValid) { #ifdef FLASH_VERBOSE safe_printk("Flash: No flash or unsupported " "manufacturer.\n"); #endif continue; } /* reset */ flashStart[unlockAddress1] = unlockData1; flashStart[unlockAddress2] = unlockData2; flashStart[unlockAddress1] = resetData; /* read device id */ flashStart[unlockAddress1] = unlockData1; flashStart[unlockAddress2] = unlockData2; flashStart[unlockAddress1] = manufacturerUnlockData; #ifdef FLASH_8BITX4 manu_long = flashStart[deviceIdAddress]; manu_long &= 0x000000ff; switch(chip->manufacturer_id) { case ManufacturerAMD: manu_long |= 0x00002200; break; case ManufacturerSST: manu_long |= 0x00002700; break; case ManufacturerToshiba: case ManufacturerST: break; } chip->device_id = manu_long; #else chip->device_id = flashStart[deviceIdAddress]; #endif /*FLASH_8BITX4*/ /* reset */ flashStart[unlockAddress1] = unlockData1; flashStart[unlockAddress2] = unlockData2; flashStart[unlockAddress1] = resetData; #endif /*CONFIG_SVINTO_SIM*/ /* check device type and fill in correct sizes etc */ switch(chip->device_id) { case AM29LV322DT: case AM29LV323DT: #ifdef FLASH_VERBOSE safe_printk("Flash: 32Mb TB.\n"); #endif chip->size = FL_SIZEOF(0x00400000); chip->sectorsize = FL_SIZEOF(0x10000); chip->bootsector = chip->start + chip->size - chip->sectorsize; chip->bootsectorsize[0] = FL_SIZEOF(0x2000); chip->bootsectorsize[1] = FL_SIZEOF(0x2000); chip->bootsectorsize[2] = FL_SIZEOF(0x2000); chip->bootsectorsize[3] = FL_SIZEOF(0x2000); chip->bootsectorsize[4] = FL_SIZEOF(0x2000); chip->bootsectorsize[5] = FL_SIZEOF(0x2000); chip->bootsectorsize[6] = FL_SIZEOF(0x2000); chip->bootsectorsize[7] = FL_SIZEOF(0x2000); break; case AM29LV322DB: case AM29LV323DB: #ifdef FLASH_VERBOSE safe_printk("Flash: 32Mb BB.\n"); #endif chip->size = FL_SIZEOF(0x00400000); chip->sectorsize = FL_SIZEOF(0x10000); chip->bootsector = chip->start; chip->bootsectorsize[0] = FL_SIZEOF(0x2000); chip->bootsectorsize[1] = FL_SIZEOF(0x2000); chip->bootsectorsize[2] = FL_SIZEOF(0x2000); chip->bootsectorsize[3] = FL_SIZEOF(0x2000); chip->bootsectorsize[4] = FL_SIZEOF(0x2000); chip->bootsectorsize[5] = FL_SIZEOF(0x2000); chip->bootsectorsize[6] = FL_SIZEOF(0x2000); chip->bootsectorsize[7] = FL_SIZEOF(0x2000); break; case AM29LV160BT: case TC58FVT160: #ifdef FLASH_VERBOSE safe_printk("Flash: 16Mb TB.\n"); #endif chip->size = FL_SIZEOF(0x00200000); chip->sectorsize = FL_SIZEOF(0x10000); chip->bootsector = chip->start + chip->size - chip->sectorsize; chip->bootsectorsize[0] = FL_SIZEOF(0x8000); chip->bootsectorsize[1] = FL_SIZEOF(0x2000); chip->bootsectorsize[2] = FL_SIZEOF(0x2000); chip->bootsectorsize[3] = FL_SIZEOF(0x4000); break; case AM29LV400BB: #ifdef FLASH_VERBOSE safe_printk("Flash: AMD AM 29LV400BB - 4Megabit.\n"); #endif chip->size= FL_SIZEOF(0x00080000); chip->sectorsize = FL_SIZEOF(0x10000); chip->bootsector = chip->start; chip->bootsectorsize[0] = FL_SIZEOF(0x4000); chip->bootsectorsize[1] = FL_SIZEOF(0x2000); chip->bootsectorsize[2] = FL_SIZEOF(0x2000); chip->bootsectorsize[3] = FL_SIZEOF(0x8000); break; case AM29LV160BB: case TC58FVB160: #ifdef FLASH_VERBOSE safe_printk("Flash: 16Mb BB.\n"); #endif chip->size = FL_SIZEOF(0x00200000); chip->sectorsize = FL_SIZEOF(0x10000); chip->bootsector = chip->start; chip->bootsectorsize[0] = FL_SIZEOF(0x4000); chip->bootsectorsize[1] = FL_SIZEOF(0x2000); chip->bootsectorsize[2] = FL_SIZEOF(0x2000); chip->bootsectorsize[3] = FL_SIZEOF(0x8000); break; case AM29LV800BB: case AM29F800BB: #ifdef FLASH_VERBOSE safe_printk("Flash: 8Mb BB.\n"); #endif chip->size = FL_SIZEOF(0x00100000); chip->sectorsize = FL_SIZEOF(0x10000); chip->bootsector = chip->start; chip->bootsectorsize[0] = FL_SIZEOF(0x4000); chip->bootsectorsize[1] = FL_SIZEOF(0x2000); chip->bootsectorsize[2] = FL_SIZEOF(0x2000); chip->bootsectorsize[3] = FL_SIZEOF(0x8000); break; case M29W800T: case AM29LV800BT: case AM29F800BT: #ifdef FLASH_VERBOSE safe_printk("Flash: 8Mb TB.\n"); #endif chip->size = FL_SIZEOF(0x00100000); chip->sectorsize = FL_SIZEOF(0x10000); chip->bootsector = chip->start + chip->size - chip->sectorsize; chip->bootsectorsize[0] = FL_SIZEOF(0x8000); chip->bootsectorsize[1] = FL_SIZEOF(0x2000); chip->bootsectorsize[2] = FL_SIZEOF(0x2000); chip->bootsectorsize[3] = FL_SIZEOF(0x4000); break; // case AM29LV800BB: /* the following supports smaller sector erases (like 2 Kword) * so they dont use bootblocks. until we've implemented real * support for the smaller erases, we just treat them as if they * dont have bootblocks at all. */ case SST39LF800: #ifdef FLASH_VERBOSE safe_printk("Flash: 8Mb No B\n"); #endif chip->size = FL_SIZEOF(0x00100000); chip->sectorsize = FL_SIZEOF(0x10000); chip->bootsector = (unsigned char *)MEM_DRAM_START; /* never a flash address (see above) */ break; case SST39LF160: #ifdef FLASH_VERBOSE safe_printk("Flash: 16Mb No B\n"); #endif chip->size = FL_SIZEOF(0x00200000); chip->sectorsize = FL_SIZEOF(0x10000); chip->bootsector = (unsigned char *)MEM_DRAM_START; /* never a flash address */ break; default: #ifdef FLASH_VERBOSE safe_printk("Flash: Unknown device\n"); #endif chip->isValid = 0; break; } chip->busy = 0; init_waitqueue(&chip->wqueue); } }
int autofs_wait(struct autofs_sb_info *sbi, struct qstr * name) { struct autofs_wait_queue *wq; int status; /* In catatonic mode, we don't wait for nobody */ if ( sbi->catatonic ) return -ENOENT; for ( wq = sbi->queues ; wq ; wq = wq->next ) { if ( wq->hash == name->hash && wq->len == name->len && wq->name && !memcmp(wq->name,name->name,name->len) ) break; } if ( !wq ) { /* Create a new wait queue */ wq = kmalloc(sizeof(struct autofs_wait_queue),GFP_KERNEL); if ( !wq ) return -ENOMEM; wq->name = kmalloc(name->len,GFP_KERNEL); if ( !wq->name ) { kfree(wq); return -ENOMEM; } wq->wait_queue_token = autofs_next_wait_queue++; init_waitqueue(&wq->queue); wq->hash = name->hash; wq->len = name->len; wq->status = -EINTR; /* Status return if interrupted */ memcpy(wq->name, name->name, name->len); wq->next = sbi->queues; sbi->queues = wq; /* autofs_notify_daemon() may block */ wq->wait_ctr = 2; autofs_notify_daemon(sbi,wq); } else wq->wait_ctr++; /* wq->name is NULL if and only if the lock is already released */ if ( sbi->catatonic ) { /* We might have slept, so check again for catatonic mode */ wq->status = -ENOENT; if ( wq->name ) { kfree(wq->name); wq->name = NULL; } } if ( wq->name ) { /* Block all but "shutdown" signals while waiting */ sigset_t oldset; unsigned long irqflags; spin_lock_irqsave(¤t->sigmask_lock, irqflags); oldset = current->blocked; siginitsetinv(¤t->blocked, SHUTDOWN_SIGS & ~oldset.sig[0]); recalc_sigpending(current); spin_unlock_irqrestore(¤t->sigmask_lock, irqflags); interruptible_sleep_on(&wq->queue); spin_lock_irqsave(¤t->sigmask_lock, irqflags); current->blocked = oldset; recalc_sigpending(current); spin_unlock_irqrestore(¤t->sigmask_lock, irqflags); } else { DPRINTK(("autofs_wait: skipped sleeping\n")); } status = wq->status; if ( ! --wq->wait_ctr ) /* Are we the last process to need status? */ kfree(wq); return status; }