/** * Function to process a file, based on type of operation being * performed. By default, this prints the path. Stat information * for the file may be printed if the verbose option is turned * on. Output from this function can be turned off with the quiet * option. Then only statistics are reported by the treewalk. * * @param infile a FileInfo structure containing the * file name and stat information * @param perf a PerfStat structure to be used to * record any statistics resulting from * processing a file * @param o the options structure holding the global * options values and other shared variables * * @return zero is returned if there are no problems process the * file. Non-zero is returned if there are! */ int treewalk_process_file(FileInfo *infile, PerfStat *perf, options o) { AppOptions *twp_o = (AppOptions *)o.app_ops; // Treewalk options if(twp_o->quiet) return(0); // don't want any output, so simply return if(!infile || strIsBlank(infile->path)) { fprintf(stderr,"Worker Rank %d: treewalk_process_file() cannot print path. Blank path or no file information\n",o.rank); return(-1); } if(!twp_o->verbose) // No verbose -> just want the path printf("%s\n",infile->path); else { // stat info in ls-like format if(infile->exists < 0) // if exists flag < 0 -> no stat structure printf("[ no stat information! ] %s\n", infile->path); else { // print the whole enchilada struct tm sttm; char modebuf[15], timebuf[30]; printmode(infile->st.st_mode, modebuf); memcpy(&sttm, localtime(&infile->st.st_mtime), sizeof(sttm)); strftime(timebuf, sizeof(timebuf), "%a %b %d %Y %T", &sttm); printf("%s %6d %6d %21zd %s %s\n", modebuf, infile->st.st_uid, infile->st.st_gid, (size_t) infile->st.st_size, timebuf, infile->path); } } return(0); }
static int do_hardware_modes (ctl_table *table, int write, void __user *result, size_t *lenp, loff_t *ppos) { struct parport *port = (struct parport *)table->extra1; char buffer[40]; int len = 0; if (*ppos) { *lenp = 0; return 0; } if (write) /* permissions prevent this anyway */ return -EACCES; { #define printmode(x) {if(port->modes&PARPORT_MODE_##x){len+=sprintf(buffer+len,"%s%s",f?",":"",#x);f++;}} int f = 0; printmode(PCSPP); printmode(TRISTATE); printmode(COMPAT); printmode(EPP); printmode(ECP); printmode(DMA); #undef printmode } buffer[len++] = '\n'; if (len > *lenp) len = *lenp; else *lenp = len; *ppos += len; return copy_to_user(result, buffer, len) ? -EFAULT : 0; }
int init_one_port(struct linux_ebus_device *dev) { struct parport tmpport, *p; unsigned long base; unsigned long config; int irq, dma; /* Pointer to NS87303 Configuration Registers */ config = dev->base_address[1]; /* Setup temporary access to Device operations */ tmpport.base = dev->base_address[0]; tmpport.ops = &parport_ax_ops; /* Configure IRQ to Push Pull, Level Low */ /* Enable ECP mode, set bit 2 of the CTR first */ tmpport.ops->write_control(&tmpport, 0x04); ns87303_modify(config, PCR, PCR_EPP_ENABLE | PCR_IRQ_ODRAIN, PCR_ECP_ENABLE | PCR_ECP_CLK_ENA | PCR_IRQ_POLAR); /* LPT CTR bit 5 controls direction of parallel port */ ns87303_modify(config, PTR, 0, PTR_LPT_REG_DIR); /* * Now continue initializing the port */ base = dev->base_address[0]; irq = dev->irqs[0]; dma = PARPORT_DMA_AUTO; if (!(p = parport_register_port(base, irq, dma, &parport_ax_ops))) return 0; /* Save away pointer to our EBus DMA */ p->private_data = (void *)dev->base_address[2]; p->modes = PARPORT_MODE_PCSPP | parport_PS2_supported(p); if (!check_region(p->base + 0x400, 3)) { p->modes |= parport_ECR_present(p); p->modes |= parport_ECP_supported(p); p->modes |= parport_ECPPS2_supported(p); } p->size = 3; if (p->dma == PARPORT_DMA_AUTO) p->dma = (p->modes & PARPORT_MODE_PCECP) ? 0 : PARPORT_DMA_NONE; printk(KERN_INFO "%s: PC-style at 0x%lx", p->name, p->base); if (p->irq != PARPORT_IRQ_NONE) printk(", irq %s", __irq_itoa(p->irq)); if (p->dma != PARPORT_DMA_NONE) printk(", dma %d", p->dma); printk(" ["); { int f = 0; printmode(SPP); printmode(PS2); printmode(ECP); printmode(ECPPS2); } printk("]\n"); parport_proc_register(p); p->flags |= PARPORT_FLAG_COMA; p->ops->write_control(p, 0x0c); p->ops->write_data(p, 0); if (parport_probe_hook) (*parport_probe_hook)(p); return 1; }
struct parport *__devinit parport_gsc_probe_port (unsigned long base, unsigned long base_hi, int irq, int dma, struct pci_dev *dev) { struct parport_gsc_private *priv; struct parport_operations *ops; struct parport tmp; struct parport *p = &tmp; priv = kmalloc (sizeof (struct parport_gsc_private), GFP_KERNEL); if (!priv) { printk (KERN_DEBUG "parport (0x%lx): no memory!\n", base); return NULL; } ops = kmalloc (sizeof (struct parport_operations), GFP_KERNEL); if (!ops) { printk (KERN_DEBUG "parport (0x%lx): no memory for ops!\n", base); kfree (priv); return NULL; } memcpy (ops, &parport_gsc_ops, sizeof (struct parport_operations)); priv->ctr = 0xc; priv->ctr_writable = 0xff; priv->dma_buf = 0; priv->dma_handle = 0; priv->dev = dev; p->base = base; p->base_hi = base_hi; p->irq = irq; p->dma = dma; p->modes = PARPORT_MODE_PCSPP | PARPORT_MODE_SAFEININT; p->ops = ops; p->private_data = priv; p->physport = p; if (!parport_SPP_supported (p)) { /* No port. */ kfree (priv); return NULL; } parport_PS2_supported (p); if (!(p = parport_register_port(base, PARPORT_IRQ_NONE, PARPORT_DMA_NONE, ops))) { kfree (priv); kfree (ops); return NULL; } p->base_hi = base_hi; p->modes = tmp.modes; p->size = (p->modes & PARPORT_MODE_EPP)?8:3; p->private_data = priv; printk(KERN_INFO "%s: PC-style at 0x%lx", p->name, p->base); p->irq = irq; if (p->irq == PARPORT_IRQ_AUTO) { p->irq = PARPORT_IRQ_NONE; } if (p->irq != PARPORT_IRQ_NONE) { printk(", irq %d", p->irq); if (p->dma == PARPORT_DMA_AUTO) { p->dma = PARPORT_DMA_NONE; } } if (p->dma == PARPORT_DMA_AUTO) /* To use DMA, giving the irq is mandatory (see above) */ p->dma = PARPORT_DMA_NONE; printk(" ["); #define printmode(x) {if(p->modes&PARPORT_MODE_##x){printk("%s%s",f?",":"",#x);f++;}} { int f = 0; printmode(PCSPP); printmode(TRISTATE); printmode(COMPAT) printmode(EPP); // printmode(ECP); // printmode(DMA); } #undef printmode printk("]\n"); if (p->irq != PARPORT_IRQ_NONE) { if (request_irq (p->irq, parport_gsc_interrupt, 0, p->name, p)) { printk (KERN_WARNING "%s: irq %d in use, " "resorting to polled operation\n", p->name, p->irq); p->irq = PARPORT_IRQ_NONE; p->dma = PARPORT_DMA_NONE; } } /* Done probing. Now put the port into a sensible start-up state. */ parport_gsc_write_data(p, 0); parport_gsc_data_forward (p); /* Now that we've told the sharing engine about the port, and found out its characteristics, let the high-level drivers know about it. */ parport_announce_port (p); return p; }
void do_file_entry(const u8* base, const char* dir, const char* path, const char* name, int namelen, const struct cramfs_inode* inode) { int dirlen=strlen(dir); int pathlen=strlen(path); char pname[dirlen+pathlen+namelen+3]; const char* basename; if (dirlen) { strncpy(pname, dir, dirlen); } if (pathlen) { if (dirlen) { pname[dirlen]='/'; ++dirlen; } strncpy(pname+dirlen, path, pathlen); } if (namelen) { if (pathlen+dirlen) { pname[dirlen+pathlen]='/'; ++pathlen; } strncpy(pname+dirlen+pathlen, name, namelen); } pname[pathlen+dirlen+namelen]=0; basename=namelen ? pname+dirlen+pathlen : "/"; // Create things here printmode(inode); printuidgid(inode); if (S_ISREG(inode->mode)) { do_file(base, inode->offset<<2, inode->size, pname, basename, inode->mode); } else if (S_ISDIR(inode->mode)) { do_directory(base, inode->offset<<2, inode->size, pname, basename, inode->mode); } else if (S_ISLNK(inode->mode)) { do_symlink(base, inode->offset<<2, inode->size, pname, basename, inode->mode); } else if (S_ISFIFO(inode->mode)) { do_fifo(base, inode->offset<<2, inode->size, pname, basename, inode->mode, inode->uid, inode->gid); } else if (S_ISSOCK(inode->mode)) { do_socket(base, inode->offset<<2, inode->size, pname, basename, inode->mode); } else if (S_ISCHR(inode->mode)) { do_chrdev(base, inode->offset<<2, inode->size, pname, basename, inode->mode, inode->uid, inode->gid); } else if (S_ISBLK(inode->mode)) { do_blkdev(base, inode->offset<<2, inode->size, pname, basename, inode->mode, inode->uid, inode->gid); } else { do_unknown(base, inode->offset<<2, inode->size, pname, basename, inode->mode); } if (geteuid() == 0) { if (lchown(pname, inode->uid, inode->gid) == -1) perror("cannot change owner or group"); } else if(opt_idsfile && path && path[0]) { char dfp[1024]; char *p; FILE *f; strcpy(dfp,pname); p = strrchr(dfp,'/'); if (!p) { fprintf(stderr,"could not find path in '%s'\n",pname); return; } strcpy(p+1,opt_idsfile); f = fopen(dfp,"at"); if (!f) { perror(dfp); return; } fprintf(f,"%s,%u,%u,%08x\n",basename,inode->uid,inode->gid,inode->mode); fclose(f); } if (geteuid() == 0 || !opt_idsfile) { if (inode->mode & (S_ISGID|S_ISUID|S_ISVTX)) { if (0 != chmod(pname, inode->mode)){ perror("chmod"); return; } } } printf("\n"); }