static int nfs_get_sb(struct file_system_type *fs_type,
int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt)
{
struct nfs_server *server = NULL;
struct super_block *s;
struct nfs_fh mntfh;
struct nfs_mount_data *data = raw_data;
struct dentry *mntroot;
int error;
/* Validate the mount data */
error = nfs_validate_mount_data(data, &mntfh);
if (error < 0)
return error;
/* Get a volume representation */
server = nfs_create_server(data, &mntfh);
if (IS_ERR(server)) {
error = PTR_ERR(server);
goto out_err_noserver;
}
/* Get a superblock - note that we may end up sharing one that already exists */
s = sget(fs_type, nfs_compare_super, nfs_set_super, server);
if (IS_ERR(s)) {
error = PTR_ERR(s);
goto out_err_nosb;
}
if (s->s_fs_info != server) {
nfs_free_server(server);
server = NULL;
}
if (!s->s_root) {
/* initial superblock/root creation */
s->s_flags = flags;
nfs_fill_super(s, data);
}
mntroot = nfs_get_root(s, &mntfh);
if (IS_ERR(mntroot)) {
error = PTR_ERR(mntroot);
goto error_splat_super;
}
s->s_flags |= MS_ACTIVE;
mnt->mnt_sb = s;
mnt->mnt_root = mntroot;
return 0;
out_err_nosb:
nfs_free_server(server);
out_err_noserver:
return error;
error_splat_super:
up_write(&s->s_umount);
deactivate_super(s);
return error;
}
void p_grafik(void)
{
deftext( 1,24,0,32);
text( 174,200,-1,"4. DEMO: GRAFIK");
p_s_top();
printf("\33E");
deftext( -1,1,0,13);
for(h_long=1;h_long<=2;h_long++)
{
for(j_long=4;j_long<=24 ;j_long+= 4)
{
for(i_long=0;i_long<=5;i_long++)
{
deftext( -1,pow(2,i_long),-1,-1);
text( 320,50+i_long*(16+j_long*2),-1,"B_NACH_C");
}
pause( 10);
printf("\33E");
deftext( -1,-1,-1,j_long);
}
deftext( -1,-1,h_long*1800,-1);
}
deftext( -1,1,-1,13);
for(h_long=1;h_long<=4;h_long++)
{
for(i_long=2;i_long<=3;i_long++)
{
for(j_long=0;j_long<=2;j_long++)
{
defline( h_long,i_long,j_long,j_long);
draw(100+50*j_long,50+25*j_long , 539-50*j_long,50+25*j_long);
box( 50+50*j_long,150,320-50*j_long,350);
circle( 480,250,20+40*j_long);
}
pause( 10);
printf("\33E");
}
}
defline( 1,2,1,1);
deffill( 1,1,1);
for(i_long=2;i_long<=3;i_long++)
{
for(j_long=1;j_long<=20;j_long++)
{
deffill( 1,i_long,j_long);
pbox( 16*j_long-16,10,655-16*j_long,190);
pcircle( 160,299,105-5*j_long);
pellipse( 480,299,5*j_long,105-5*j_long);
}
if(j_long>20 & i_long==2)
{
bild_char = sget(bild_char);
}
}
pause( 50);
s_adr_long=(long)(bild_char);
d_adr_long=xbios(2);
for(i_long=1;i_long<=1000;i_long++)
{
rc_copy(s_adr_long,(int)((double)rand()*(10)/32767)*64,(int)((double)rand()*(10)/32767)*40,64,40 ,d_adr_long,(int)((double)rand()*(10)/32767)*64,(int)((double)rand()*(10)/32767)*40,
-1);
}
pause( 100);
printf("\33E");
sput( bild_char);
deffill( 1,1,1);
static int
nilfs_get_sb(struct file_system_type *fs_type, int flags,
const char *dev_name, void *data, struct vfsmount *mnt)
{
struct nilfs_super_data sd;
struct super_block *s;
struct the_nilfs *nilfs;
int err, need_to_close = 1;
sd.bdev = open_bdev_exclusive(dev_name, flags, fs_type);
if (IS_ERR(sd.bdev))
return PTR_ERR(sd.bdev);
/*
* To get mount instance using sget() vfs-routine, NILFS needs
* much more information than normal filesystems to identify mount
* instance. For snapshot mounts, not only a mount type (ro-mount
* or rw-mount) but also a checkpoint number is required.
*/
sd.cno = 0;
sd.flags = flags;
if (nilfs_identify((char *)data, &sd)) {
err = -EINVAL;
goto failed;
}
nilfs = find_or_create_nilfs(sd.bdev);
if (!nilfs) {
err = -ENOMEM;
goto failed;
}
mutex_lock(&nilfs->ns_mount_mutex);
if (!sd.cno) {
/*
* Check if an exclusive mount exists or not.
* Snapshot mounts coexist with a current mount
* (i.e. rw-mount or ro-mount), whereas rw-mount and
* ro-mount are mutually exclusive.
*/
down_read(&nilfs->ns_super_sem);
if (nilfs->ns_current &&
((nilfs->ns_current->s_super->s_flags ^ flags)
& MS_RDONLY)) {
up_read(&nilfs->ns_super_sem);
err = -EBUSY;
goto failed_unlock;
}
up_read(&nilfs->ns_super_sem);
}
/*
* Find existing nilfs_sb_info struct
*/
sd.sbi = nilfs_find_sbinfo(nilfs, !(flags & MS_RDONLY), sd.cno);
/*
* Get super block instance holding the nilfs_sb_info struct.
* A new instance is allocated if no existing mount is present or
* existing instance has been unmounted.
*/
s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, &sd);
if (sd.sbi)
nilfs_put_sbinfo(sd.sbi);
if (IS_ERR(s)) {
err = PTR_ERR(s);
goto failed_unlock;
}
if (!s->s_root) {
char b[BDEVNAME_SIZE];
/* New superblock instance created */
s->s_flags = flags;
strlcpy(s->s_id, bdevname(sd.bdev, b), sizeof(s->s_id));
sb_set_blocksize(s, block_size(sd.bdev));
err = nilfs_fill_super(s, data, flags & MS_VERBOSE, nilfs);
if (err)
goto cancel_new;
s->s_flags |= MS_ACTIVE;
need_to_close = 0;
}
mutex_unlock(&nilfs->ns_mount_mutex);
put_nilfs(nilfs);
if (need_to_close)
close_bdev_exclusive(sd.bdev, flags);
simple_set_mnt(mnt, s);
return 0;
failed_unlock:
mutex_unlock(&nilfs->ns_mount_mutex);
put_nilfs(nilfs);
failed:
close_bdev_exclusive(sd.bdev, flags);
return err;
cancel_new:
/* Abandoning the newly allocated superblock */
mutex_unlock(&nilfs->ns_mount_mutex);
put_nilfs(nilfs);
deactivate_locked_super(s);
/*
* deactivate_super() invokes close_bdev_exclusive().
* We must finish all post-cleaning before this call;
* put_nilfs() needs the block device.
*/
return err;
}
void
dumpsys(void)
{
u_long totalbytesleft, bytes, i, n, memseg;
u_long maddr;
daddr_t blkno;
int (*dump)(dev_t, daddr_t, caddr_t, size_t);
int error;
/* Save registers. */
savectx(&dumppcb);
if (dumpdev == NODEV)
return;
/*
* For dumps during autoconfiguration,
* if dump device has already configured...
*/
if (dumpsize == 0)
dumpconf();
if (dumplo <= 0 || dumpsize == 0) {
printf("\ndump to dev %u,%u not possible\n", major(dumpdev),
minor(dumpdev));
return;
}
printf("\ndumping to dev %u,%u offset %ld\n", major(dumpdev),
minor(dumpdev), dumplo);
error = (*bdevsw[major(dumpdev)].d_psize)(dumpdev);
printf("dump ");
if (error == -1) {
printf("area unavailable\n");
return;
}
if ((error = cpu_dump()) != 0)
goto err;
totalbytesleft = ptoa(cpu_dump_mempagecnt());
blkno = dumplo + cpu_dumpsize();
dump = bdevsw[major(dumpdev)].d_dump;
error = 0;
for (memseg = 0; memseg < mem_cluster_cnt; memseg++) {
maddr = mem_clusters[memseg].start;
bytes = mem_clusters[memseg].size;
for (i = 0; i < bytes; i += n, totalbytesleft -= n) {
/* Print out how many MBs we have left to go. */
if ((totalbytesleft % (1024*1024)) == 0)
printf("%ld ", totalbytesleft / (1024 * 1024));
/* Limit size for next transfer. */
n = bytes - i;
if (n > BYTES_PER_DUMP)
n = BYTES_PER_DUMP;
(void) pmap_map(dumpspace, maddr, maddr + n,
VM_PROT_READ);
error = (*dump)(dumpdev, blkno, (caddr_t)dumpspace, n);
if (error)
goto err;
maddr += n;
blkno += btodb(n); /* XXX? */
#if 0 /* XXX this doesn't work. grr. */
/* operator aborting dump? */
if (sget() != NULL) {
error = EINTR;
break;
}
#endif
}
}
err:
switch (error) {
case ENXIO:
printf("device bad\n");
break;
case EFAULT:
printf("device not ready\n");
break;
case EINVAL:
printf("area improper\n");
break;
case EIO:
printf("i/o error\n");
break;
case EINTR:
printf("aborted from console\n");
break;
case 0:
printf("succeeded\n");
break;
default:
printf("error %d\n", error);
break;
}
printf("\n\n");
delay(5000000); /* 5 seconds */
}
void *
readdesc(const char *name)
{
char *cmd, *p, *q;
int i, totfont, v;
char *cpout, *fpout;
size_t sz, fsz;
char *dir, *dp, *dq;
struct mfile *mp;
memset(&dev, 0, sizeof dev);
if ((mp = mopen(name)) == NULL) {
errprint("can't open tables for %s", name);
return NULL;
}
while ((cmd = sget(mp)) != NULL) {
if (cmd[0] == '#') /* comment */
skipline(mp);
else if (strcmp(cmd, "res") == 0) {
dget(mp, &dev.res);
} else if (strcmp(cmd, "hor") == 0) {
dget(mp, &dev.hor);
} else if (strcmp(cmd, "vert") == 0) {
dget(mp, &dev.vert);
} else if (strcmp(cmd, "unitwidth") == 0) {
dget(mp, &dev.unitwidth);
} else if (strcmp(cmd, "sizescale") == 0) {
dget(mp, &dev.sizescale);
} else if (strcmp(cmd, "paperwidth") == 0) {
dget(mp, &dev.paperwidth);
} else if (strcmp(cmd, "paperlength") == 0) {
dget(mp, &dev.paperlength);
} else if (strcmp(cmd, "biggestfont") == 0) {
dget(mp, &dev.biggestfont);
} else if (strcmp(cmd, "spare2") == 0) {
dget(mp, &dev.spare2);
} else if (strcmp(cmd, "encoding") == 0) {
dget(mp, &dev.encoding);
} else if (strcmp(cmd, "allpunct") == 0) {
dev.allpunct = 1;
} else if (strcmp(cmd, "anysize") == 0) {
dev.anysize = 1;
} else if (strcmp(cmd, "afmfonts") == 0) {
dev.afmfonts = 1;
} else if (strcmp(cmd, "lc_ctype") == 0) {
dev.lc_ctype = 1;
} else if (strcmp(cmd, "sizes") == 0) {
dev.nsizes = 0;
while (dget(mp, &v) != EOF && v != 0)
size[dev.nsizes++] = v;
size[dev.nsizes] = 0; /* need an extra 0 at the end */
} else if (strcmp(cmd, "fonts") == 0) {
dget(mp, &dev.nfonts);
for (i = 0; i < dev.nfonts; i++)
if ((p = sget(mp)) != NULL)
strncpy(fname[i], p,
sizeof fname[i] - 1);
} else if (strcmp(cmd, "charset") == 0) {
p = chname;
dev.nchtab = 0;
while ((q = sget(mp)) != NULL) {
strcpy(p, q);
chtab[dev.nchtab++] = p - chname;
while (*p++) /* skip to end of name */
;
}
dev.lchname = p - chname;
chtab[dev.nchtab++] = 0; /* terminate properly */
} else
errprint("Unknown command %s in %s", cmd, name);
}
cpout = calloc(1, sz = sizeof dev +
sizeof *size * (dev.nsizes+1) +
sizeof *chtab * dev.nchtab +
sizeof *chname * dev.lchname);
memcpy(cpout, &dev, sizeof dev);
v = sizeof dev;
memcpy(&cpout[v], size, sizeof *size * (dev.nsizes+1));
v += sizeof *size * (dev.nsizes+1);
memcpy(&cpout[v], chtab, sizeof *chtab * dev.nchtab);
v += sizeof *chtab * dev.nchtab;
memcpy(&cpout[v], chname, sizeof *chname * dev.lchname);
v += sizeof *chname * dev.lchname;
dp = dir = malloc(strlen(name) + sizeof fname[0] + 2);
strcpy(dir, name);
for (dq = dir; *dq; dq++)
if (*dq == '/')
dp = &dq[1];
totfont = 0;
for (i = 0; i < dev.nfonts; i++) {
strcpy(dp, fname[i]);
if ((fpout = _readfont(dir, &fsz, 1)) == NULL) {
mclose(mp);
return NULL;
}
sz += fsz;
cpout = realloc(cpout, sz);
memcpy(&cpout[v], fpout, fsz);
v += fsz;
free(fpout);
totfont += fsz;
}
/* back to beginning to install proper size */
dev.filesize = /* excluding dev struct itself */
(dev.nsizes+1) * sizeof(size[0])
+ dev.nchtab * sizeof(chtab[0])
+ dev.lchname * sizeof(chname[0])
+ totfont * sizeof(char);
memcpy(cpout, &dev, sizeof dev);
mclose(mp);
return cpout;
}
static int
nilfs_get_sb(struct file_system_type *fs_type, int flags,
const char *dev_name, void *data, struct vfsmount *mnt)
{
struct nilfs_super_data sd;
struct super_block *s;
fmode_t mode = FMODE_READ;
struct dentry *root_dentry;
int err, s_new = false;
if (!(flags & MS_RDONLY))
mode |= FMODE_WRITE;
sd.bdev = open_bdev_exclusive(dev_name, mode, fs_type);
if (IS_ERR(sd.bdev))
return PTR_ERR(sd.bdev);
sd.cno = 0;
sd.flags = flags;
if (nilfs_identify((char *)data, &sd)) {
err = -EINVAL;
goto failed;
}
/*
* once the super is inserted into the list by sget, s_umount
* will protect the lockfs code from trying to start a snapshot
* while we are mounting
*/
mutex_lock(&sd.bdev->bd_fsfreeze_mutex);
if (sd.bdev->bd_fsfreeze_count > 0) {
mutex_unlock(&sd.bdev->bd_fsfreeze_mutex);
err = -EBUSY;
goto failed;
}
s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, sd.bdev);
mutex_unlock(&sd.bdev->bd_fsfreeze_mutex);
if (IS_ERR(s)) {
err = PTR_ERR(s);
goto failed;
}
if (!s->s_root) {
char b[BDEVNAME_SIZE];
s_new = true;
/* New superblock instance created */
s->s_flags = flags;
s->s_mode = mode;
strlcpy(s->s_id, bdevname(sd.bdev, b), sizeof(s->s_id));
sb_set_blocksize(s, block_size(sd.bdev));
err = nilfs_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
if (err)
goto failed_super;
s->s_flags |= MS_ACTIVE;
} else if (!sd.cno) {
int busy = false;
if (nilfs_tree_was_touched(s->s_root)) {
busy = nilfs_try_to_shrink_tree(s->s_root);
if (busy && (flags ^ s->s_flags) & MS_RDONLY) {
printk(KERN_ERR "NILFS: the device already "
"has a %s mount.\n",
(s->s_flags & MS_RDONLY) ?
"read-only" : "read/write");
err = -EBUSY;
goto failed_super;
}
}
if (!busy) {
/*
* Try remount to setup mount states if the current
* tree is not mounted and only snapshots use this sb.
*/
err = nilfs_remount(s, &flags, data);
if (err)
goto failed_super;
}
}
if (sd.cno) {
err = nilfs_attach_snapshot(s, sd.cno, &root_dentry);
if (err)
goto failed_super;
} else {
root_dentry = dget(s->s_root);
}
if (!s_new)
close_bdev_exclusive(sd.bdev, mode);
mnt->mnt_sb = s;
mnt->mnt_root = root_dentry;
return 0;
failed_super:
deactivate_locked_super(s);
failed:
if (!s_new)
close_bdev_exclusive(sd.bdev, mode);
return err;
}
static struct dentry *
nilfs_mount(struct file_system_type *fs_type, int flags,
const char *dev_name, void *data)
{
struct nilfs_super_data sd;
struct super_block *s;
fmode_t mode = FMODE_READ | FMODE_EXCL;
struct dentry *root_dentry;
int err, s_new = false;
if (!(flags & MS_RDONLY))
mode |= FMODE_WRITE;
sd.bdev = blkdev_get_by_path(dev_name, mode, fs_type);
if (IS_ERR(sd.bdev))
return ERR_CAST(sd.bdev);
sd.cno = 0;
sd.flags = flags;
if (nilfs_identify((char *)data, &sd)) {
err = -EINVAL;
goto failed;
}
/*
* once the super is inserted into the list by sget, s_umount
* will protect the lockfs code from trying to start a snapshot
* while we are mounting
*/
mutex_lock(&sd.bdev->bd_fsfreeze_mutex);
if (sd.bdev->bd_fsfreeze_count > 0) {
mutex_unlock(&sd.bdev->bd_fsfreeze_mutex);
err = -EBUSY;
goto failed;
}
s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, flags,
sd.bdev);
mutex_unlock(&sd.bdev->bd_fsfreeze_mutex);
if (IS_ERR(s)) {
err = PTR_ERR(s);
goto failed;
}
if (!s->s_root) {
s_new = true;
/* New superblock instance created */
s->s_mode = mode;
snprintf(s->s_id, sizeof(s->s_id), "%pg", sd.bdev);
sb_set_blocksize(s, block_size(sd.bdev));
err = nilfs_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
if (err)
goto failed_super;
s->s_flags |= MS_ACTIVE;
} else if (!sd.cno) {
if (nilfs_tree_is_busy(s->s_root)) {
if ((flags ^ s->s_flags) & MS_RDONLY) {
nilfs_msg(s, KERN_ERR,
"the device already has a %s mount.",
(s->s_flags & MS_RDONLY) ?
"read-only" : "read/write");
err = -EBUSY;
goto failed_super;
}
} else {
/*
* Try remount to setup mount states if the current
* tree is not mounted and only snapshots use this sb.
*/
err = nilfs_remount(s, &flags, data);
if (err)
goto failed_super;
}
}
if (sd.cno) {
err = nilfs_attach_snapshot(s, sd.cno, &root_dentry);
if (err)
goto failed_super;
} else {
root_dentry = dget(s->s_root);
}
if (!s_new)
blkdev_put(sd.bdev, mode);
return root_dentry;
failed_super:
deactivate_locked_super(s);
failed:
if (!s_new)
blkdev_put(sd.bdev, mode);
return ERR_PTR(err);
}
void
slangprintentry(Entry e, int cmd)
{
char *p, *pe, *vs, *ve;
long t;
p = e.start;
pe = e.end;
if(cmd == 'h') {
t = sget(p, pe, &vs, &ve);
if(t == ME)
soutpiece(vs, ve);
outnl(0);
return;
}
while(p < pe) {
switch(sget(p, pe, &vs, &ve)) {
case DF:
soutpiece(vs, ve);
outchars(". ");
break;
case DX:
soutpiece(vs, ve);
outchars(". ");
break;
case ET:
outchars("[");
soutpiece(vs, ve);
outchars("] ");
break;
case EX:
outchars("E.g., ");
soutpiece(vs, ve);
outchars(". ");
break;
case LA:
outchars("(");
soutpiece(vs, ve);
outchars(") ");
break;
case ME:
outnl(0);
soutpiece(vs, ve);
outnl(0);
break;
case NU:
outnl(2);
soutpiece(vs, ve);
outchars(". ");
break;
case PR:
outchars("[");
soutpiece(vs, ve);
outchars("] ");
break;
case PS:
outnl(1);
soutpiece(vs, ve);
outchars(". ");
break;
case XR:
outchars("See ");
soutpiece(vs, ve);
outchars(". ");
break;
case XX:
outchars("See ");
soutpiece(vs, ve);
outchars(". ");
break;
default:
ve = pe; /* will end loop */
break;
}
p = ve;
}
outnl(0);
}
struct dentry *orangefs_mount(struct file_system_type *fst,
int flags,
const char *devname,
void *data)
{
int ret = -EINVAL;
struct super_block *sb = ERR_PTR(-EINVAL);
struct orangefs_kernel_op_s *new_op;
struct dentry *d = ERR_PTR(-EINVAL);
gossip_debug(GOSSIP_SUPER_DEBUG,
"orangefs_mount: called with devname %s\n",
devname);
if (!devname) {
gossip_err("ERROR: device name not specified.\n");
return ERR_PTR(-EINVAL);
}
new_op = op_alloc(ORANGEFS_VFS_OP_FS_MOUNT);
if (!new_op)
return ERR_PTR(-ENOMEM);
strncpy(new_op->upcall.req.fs_mount.orangefs_config_server,
devname,
ORANGEFS_MAX_SERVER_ADDR_LEN);
gossip_debug(GOSSIP_SUPER_DEBUG,
"Attempting ORANGEFS Mount via host %s\n",
new_op->upcall.req.fs_mount.orangefs_config_server);
ret = service_operation(new_op, "orangefs_mount", 0);
gossip_debug(GOSSIP_SUPER_DEBUG,
"orangefs_mount: mount got return value of %d\n", ret);
if (ret)
goto free_op;
if (new_op->downcall.resp.fs_mount.fs_id == ORANGEFS_FS_ID_NULL) {
gossip_err("ERROR: Retrieved null fs_id\n");
ret = -EINVAL;
goto free_op;
}
sb = sget(fst, NULL, set_anon_super, flags, NULL);
if (IS_ERR(sb)) {
d = ERR_CAST(sb);
goto free_op;
}
ret = orangefs_fill_sb(sb,
&new_op->downcall.resp.fs_mount, data,
flags & MS_SILENT ? 1 : 0);
if (ret) {
d = ERR_PTR(ret);
goto free_op;
}
/*
* on successful mount, store the devname and data
* used
*/
strncpy(ORANGEFS_SB(sb)->devname,
devname,
ORANGEFS_MAX_SERVER_ADDR_LEN);
/* mount_pending must be cleared */
ORANGEFS_SB(sb)->mount_pending = 0;
/*
* finally, add this sb to our list of known orangefs
* sb's
*/
gossip_debug(GOSSIP_SUPER_DEBUG,
"Adding SB %p to orangefs superblocks\n",
ORANGEFS_SB(sb));
spin_lock(&orangefs_superblocks_lock);
list_add_tail(&ORANGEFS_SB(sb)->list, &orangefs_superblocks);
spin_unlock(&orangefs_superblocks_lock);
op_release(new_op);
return dget(sb->s_root);
free_op:
gossip_err("orangefs_mount: mount request failed with %d\n", ret);
if (ret == -EINVAL) {
gossip_err("Ensure that all orangefs-servers have the same FS configuration files\n");
gossip_err("Look at pvfs2-client-core log file (typically /tmp/pvfs2-client.log) for more details\n");
}
op_release(new_op);
return d;
}
void
dodumpsys(void)
{
const struct bdevsw *bdev;
int dumpend, psize;
int error;
if (dumpdev == NODEV)
return;
bdev = bdevsw_lookup(dumpdev);
if (bdev == NULL || bdev->d_psize == NULL)
return;
/*
* For dumps during autoconfiguration,
* if dump device has already configured...
*/
if (dumpsize == 0)
cpu_dumpconf();
if (dumplo <= 0 || dumpsize == 0) {
printf("\ndump to dev %u,%u not possible\n", major(dumpdev),
minor(dumpdev));
return;
}
printf("\ndumping to dev %u,%u offset %ld\n", major(dumpdev),
minor(dumpdev), dumplo);
psize = (*bdev->d_psize)(dumpdev);
printf("dump ");
if (psize == -1) {
printf("area unavailable\n");
return;
}
#if 0 /* XXX this doesn't work. grr. */
/* toss any characters present prior to dump */
while (sget() != NULL); /*syscons and pccons differ */
#endif
dump_seg_prep();
dumpend = dumplo + btodb(dump_header_size) + ctod(dump_npages);
if (dumpend > psize) {
printf("failed: insufficient space (%d < %d)\n",
psize, dumpend);
goto failed;
}
dump_header_start();
if ((error = cpu_dump()) != 0)
goto err;
if ((error = dump_header_finish()) != 0)
goto err;
if (dump_header_blkno != dumplo + btodb(dump_header_size)) {
printf("BAD header size (%ld [written] != %ld [expected])\n",
(long)(dump_header_blkno - dumplo),
(long)btodb(dump_header_size));
goto failed;
}
dump_totalbytesleft = roundup(ptoa(dump_npages), BYTES_PER_DUMP);
error = dump_seg_iter(dumpsys_seg);
if (error == 0 && dump_header_blkno != dumpend) {
printf("BAD dump size (%ld [written] != %ld [expected])\n",
(long)(dumpend - dumplo),
(long)(dump_header_blkno - dumplo));
goto failed;
}
err:
switch (error) {
case ENXIO:
printf("device bad\n");
break;
case EFAULT:
printf("device not ready\n");
break;
case EINVAL:
printf("area improper\n");
break;
case EIO:
printf("i/o error\n");
break;
case EINTR:
printf("aborted from console\n");
break;
case 0:
printf("succeeded\n");
break;
default:
printf("error %d\n", error);
break;
}
failed:
printf("\n\n");
delay(5000000); /* 5 seconds */
}
static int ubifs_get_sb(struct file_system_type *fs_type, int flags,
const char *name, void *data, struct vfsmount *mnt)
{
struct ubi_volume_desc *ubi;
struct ubi_volume_info vi;
struct super_block *sb;
int err;
dbg_gen("name %s, flags %#x", name, flags);
/*
* Get UBI device number and volume ID. Mount it read-only so far
* because this might be a new mount point, and UBI allows only one
* read-write user at a time.
*/
ubi = open_ubi(name, UBI_READONLY);
if (IS_ERR(ubi)) {
ubifs_err("cannot open \"%s\", error %d",
name, (int)PTR_ERR(ubi));
return PTR_ERR(ubi);
}
ubi_get_volume_info(ubi, &vi);
dbg_gen("opened ubi%d_%d", vi.ubi_num, vi.vol_id);
sb = sget(fs_type, &sb_test, &sb_set, &vi.cdev);
if (IS_ERR(sb)) {
err = PTR_ERR(sb);
goto out_close;
}
if (sb->s_root) {
/* A new mount point for already mounted UBIFS */
dbg_gen("this ubi volume is already mounted");
if ((flags ^ sb->s_flags) & MS_RDONLY) {
err = -EBUSY;
goto out_deact;
}
} else {
sb->s_flags = flags;
/*
* Pass 'ubi' to 'fill_super()' in sb->s_fs_info where it is
* replaced by 'c'.
*/
sb->s_fs_info = ubi;
err = ubifs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
if (err)
goto out_deact;
/* We do not support atime */
sb->s_flags |= MS_ACTIVE | MS_NOATIME;
}
/* 'fill_super()' opens ubi again so we must close it here */
ubi_close_volume(ubi);
ubifs_sb = sb;
return 0;
out_deact:
up_write(&sb->s_umount);
out_close:
ubi_close_volume(ubi);
return err;
}
static int jffs2_get_sb_mtd(struct file_system_type *fs_type,
int flags, const char *dev_name,
void *data, struct mtd_info *mtd,
struct vfsmount *mnt)
{
struct super_block *sb;
struct jffs2_sb_info *c;
int ret;
c = kzalloc(sizeof(*c), GFP_KERNEL);
if (!c)
return -ENOMEM;
c->mtd = mtd;
sb = sget(fs_type, jffs2_sb_compare, jffs2_sb_set, c);
if (IS_ERR(sb))
goto out_error;
if (sb->s_root) {
/* New mountpoint for JFFS2 which is already mounted */
D1(printk(KERN_DEBUG "jffs2_get_sb_mtd(): Device %d (\"%s\") is already mounted\n",
mtd->index, mtd->name));
ret = simple_set_mnt(mnt, sb);
goto out_put;
}
D1(printk(KERN_DEBUG "jffs2_get_sb_mtd(): New superblock for device %d (\"%s\")\n",
mtd->index, mtd->name));
/* Initialize JFFS2 superblock locks, the further initialization will be
* done later */
init_MUTEX(&c->alloc_sem);
init_MUTEX(&c->erase_free_sem);
init_waitqueue_head(&c->erase_wait);
init_waitqueue_head(&c->inocache_wq);
spin_lock_init(&c->erase_completion_lock);
spin_lock_init(&c->inocache_lock);
sb->s_op = &jffs2_super_operations;
sb->s_flags = flags | MS_NOATIME;
sb->s_xattr = jffs2_xattr_handlers;
#ifdef CONFIG_JFFS2_FS_POSIX_ACL
sb->s_flags |= MS_POSIXACL;
#endif
ret = jffs2_do_fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
if (ret) {
/* Failure case... */
up_write(&sb->s_umount);
deactivate_super(sb);
return ret;
}
sb->s_flags |= MS_ACTIVE;
return simple_set_mnt(mnt, sb);
out_error:
ret = PTR_ERR(sb);
out_put:
kfree(c);
put_mtd_device(mtd);
return ret;
}
static struct dentry *lofs_mount(
struct file_system_type *fs_type,
int flags,
const char *dev_name,
void *raw_data)
{
static const struct qstr slash = { .name = "/", .len = 1 };
struct super_block *s;
struct lofs_sb_info *sbi;
struct lofs_dentry_info *root_info;
struct inode *inode;
const char *err = "Getting sb failed";
struct path path;
int rc;
sbi = kmem_cache_zalloc(lofs_sb_info_cache, GFP_KERNEL);
if (!sbi) {
rc = -ENOMEM;
goto out;
}
s = sget(fs_type, NULL, set_anon_super, NULL);
if (IS_ERR(s)) {
rc = PTR_ERR(s);
goto out;
}
s->s_flags = flags;
#if defined(HAVE_BACKING_DEV)
rc = bdi_setup_and_register(&sbi->bdi, "lofs", BDI_CAP_MAP_COPY);
if (rc)
goto out1;
s->s_bdi = &sbi->bdi;
#endif
lofs_set_superblock_private(s, sbi);
/* ->kill_sb() will take care of sbi after that point */
sbi = NULL;
s->s_op = &lofs_sops;
s->s_d_op = &lofs_dops;
err = "Reading sb failed";
rc = kern_path(slash.name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path);
if (rc) {
lofs_printk(KERN_WARNING, "kern_path() failed\n");
goto out1;
}
lofs_set_superblock_lower(s, path.dentry->d_sb);
s->s_maxbytes = path.dentry->d_sb->s_maxbytes;
s->s_blocksize = path.dentry->d_sb->s_blocksize;
s->s_magic = 0x10f5;
inode = lofs_get_inode(path.dentry->d_inode, s);
rc = PTR_ERR(inode);
if (IS_ERR(inode)) {
goto out_free;
}
#ifdef HAVE_D_MAKE_ROOT
s->s_root = d_make_root(inode);
#else
s->s_root = d_alloc_root(inode);
if (!s->s_root) {
iput(inode);
}
#endif
if (!s->s_root) {
rc = -ENOMEM;
goto out_free;
}
rc = -ENOMEM;
root_info = kmem_cache_zalloc(lofs_dentry_info_cache, GFP_KERNEL);
if (!root_info)
goto out_free;
/* ->kill_sb() will take care of root_info */
lofs_set_dentry_private(s->s_root, root_info);
lofs_set_dentry_lower(s->s_root, path.dentry);
lofs_set_dentry_lower_mnt(s->s_root, path.mnt);
s->s_flags |= MS_ACTIVE;
return dget(s->s_root);
out_free:
path_put(&path);
out1:
deactivate_locked_super(s);
out:
if (sbi) {
kmem_cache_free(lofs_sb_info_cache, sbi);
}
printk(KERN_ERR "%s; rc = [%d]\n", err, rc);
return ERR_PTR(rc);
}
/**
* lofs_kill_block_super
* @sb: The lofs super block
*
* Used to bring the superblock down and free the private data.
*/
static void lofs_kill_block_super(struct super_block *sb)
{
struct lofs_sb_info *sb_info = lofs_superblock_to_private(sb);
kill_anon_super(sb);
#if defined(HAVE_BACKING_DEV)
if (sb_info) {
bdi_destroy(&sb_info->bdi);
}
#endif
kmem_cache_free(lofs_sb_info_cache, sb_info);
}
#else /* !HAVE_MOUNT_IN_FS_TYPE */
/**
* lofs_fill_super
* @sb: The lofs super block
* @raw_data: The options passed to mount
* @silent: Not used but required by function prototype
*
* Sets up what we can of the sb, rest is done in lofs_read_super
*
* Returns zero on success; non-zero otherwise
*/
static int
lofs_fill_super(struct super_block *sb, void *raw_data, int silent)
{
int rc = 0;
struct inode *inode;
struct nameidata nd;
/* Released in lofs_put_super() */
struct lofs_sb_info *sbi;
sbi = kmem_cache_zalloc(lofs_sb_info_cache, GFP_KERNEL);
if (!sbi) {
lofs_printk(KERN_WARNING, "Out of memory\n");
return -ENOMEM;
}
lofs_set_superblock_private(sb, sbi);
sb->s_op = (struct super_operations *) &lofs_sops;
/* Released through deactivate_super(sb) from get_sb_nodev */
#if defined(HAVE_S_D_OP)
sb->s_d_op = &lofs_dops;
#endif
rc = path_lookup("/", LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &nd);
if (rc) {
lofs_printk(KERN_WARNING, "path_lookup() failed\n");
return rc;
}
lofs_set_superblock_lower(sb, NAMEIDATA_TO_DENTRY(&nd)->d_sb);
sb->s_maxbytes = NAMEIDATA_TO_DENTRY(&nd)->d_sb->s_maxbytes;
sb->s_blocksize = NAMEIDATA_TO_DENTRY(&nd)->d_sb->s_blocksize;
#ifdef HAVE_ADDRESS_SPACE_OPS_EXT
sb->s_flags |= MS_HAS_NEW_AOPS;
#endif
/* Get the root inode and dentry. We have to bootstrap this one,
* since it doesn't get created via the regular lookup mechanism.
*/
inode = lofs_get_inode(NAMEIDATA_TO_DENTRY(&nd)->d_inode, sb);
if (IS_ERR(inode)) {
dput(NAMEIDATA_TO_DENTRY(&nd));
mntput(NAMEIDATA_TO_VFSMNT(&nd));
return PTR_ERR(inode);
}
sb->s_root = d_alloc_root(inode);
if (!sb->s_root) {
iput(inode);
dput(NAMEIDATA_TO_DENTRY(&nd));
mntput(NAMEIDATA_TO_VFSMNT(&nd));
return -ENOMEM;
}
lofs_set_dentry_private(sb->s_root,
kmem_cache_zalloc(lofs_dentry_info_cache, GFP_KERNEL));
lofs_set_dentry_lower(sb->s_root, NAMEIDATA_TO_DENTRY(&nd));
lofs_set_dentry_lower_mnt(sb->s_root, NAMEIDATA_TO_VFSMNT(&nd));
#if !defined(HAVE_S_D_OP)
sb->s_root->d_op = (struct dentry_operations *) &lofs_dops;
#endif
return 0;
}
static void *
_readfont(const char *name, size_t *szp, int warn) /* create fitab and width tab for font */
{
struct mfile *mp;
int i, nw = 0, spacewidth, n = 0, v;
char *ch, *cmd;
char *cpout;
if ((mp = mopen(name)) == NULL) {
if (warn)
errprint("Can't load font %s", name);
return NULL;
}
for (i = 0; i < NFITAB; i++)
fitab[i] = 0;
for (i = 0; i < FSIZE; i++)
width[i] = kern[i] = code[i] = 0;
font.specfont = font.ligfont = spacewidth = 0;
while ((cmd = sget(mp)) != NULL) {
if (cmd[0] == '#')
skipline(mp);
else if (strcmp(cmd, "name") == 0) {
if ((ch = sget(mp)) != NULL)
strncpy(font.namefont, ch,
sizeof font.namefont - 1);
} else if (strcmp(cmd, "internalname") == 0) {
if ((ch = sget(mp)) != NULL)
strncpy(font.intname, ch,
sizeof font.intname - 1);
} else if (strcmp(cmd, "special") == 0)
font.specfont = 1;
else if (strcmp(cmd, "spare1") == 0)
cget(mp);
else if (strcmp(cmd, "ligatures") == 0) {
font.ligfont = getlig(mp, warn);
} else if (strcmp(cmd, "spacewidth") == 0) {
dget(mp, &spacewidth);
width[0] = spacewidth; /* width of space on this font */
} else if (strcmp(cmd, "charset") == 0) {
skipline(mp);
nw = 0;
/* widths are origin 1 so fitab==0 can mean "not there" */
while ((ch = sget(mp)) != NULL) {
if (peek(mp) != '"') { /* it's a genuine new character */
nw++;
dget(mp, &i);
width[nw] = i;
dget(mp, &i);
kern[nw] = i;
iget(mp, &i, 0);
code[nw] = i;
}
/* otherwise it's a synonym for previous character,
* so leave previous values intact
*/
if (strlen(ch) == 1) /* it's ascii */
fitab[ch[0] - 32] = nw; /* fitab origin omits non-graphics */
else if (strcmp(ch, "---") != 0) { /* it has a 2-char name */
for (i = 0; i < dev.nchtab; i++)
if (strcmp(&chname[chtab[i]], ch) == 0) {
fitab[i + 128-32] = nw; /* starts after the ascii */
break;
}
if (i >= dev.nchtab && warn)
errprint("font %s: %s not in charset\n", name, ch);
}
skipline(mp);
}
nw++;
if (dev.biggestfont >= nw)
n = dev.biggestfont;
else {
if (dev.biggestfont > 0 && warn)
errprint("font %s too big\n", name);
n = nw;
}
font.nwfont = n;
}
}
if (spacewidth == 0)
width[0] = dev.res * dev.unitwidth / 72 / 3;
cpout = calloc(1, sizeof font +
sizeof *width * (font.nwfont & BYTEMASK) +
sizeof *kern * (font.nwfont & BYTEMASK) +
sizeof *code * (font.nwfont & BYTEMASK) +
sizeof *fitab * dev.nchtab+128-32);
memcpy(cpout, &font, sizeof font);
v = sizeof font;
memcpy(&cpout[v], width, sizeof *width * (font.nwfont & BYTEMASK));
v += sizeof *width * (font.nwfont & BYTEMASK);
memcpy(&cpout[v], kern, sizeof *kern * (font.nwfont & BYTEMASK));
v += sizeof *kern * (font.nwfont & BYTEMASK);
memcpy(&cpout[v], code, sizeof *code * (font.nwfont & BYTEMASK));
v += sizeof *code * (font.nwfont & BYTEMASK);
memcpy(&cpout[v], fitab, sizeof *fitab * dev.nchtab+128-32);
v += sizeof *fitab * dev.nchtab+128-32;
if (szp)
*szp = v;
mclose(mp);
return cpout;
}
/*
* Get the superblock for an NFS4 mountpoint
*/
static int nfs4_get_sb(struct file_system_type *fs_type,
int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt)
{
struct nfs4_mount_data *data = raw_data;
struct super_block *s;
struct nfs_server *server;
struct sockaddr_in addr;
rpc_authflavor_t authflavour;
struct nfs_fh mntfh;
struct dentry *mntroot;
char *mntpath = NULL, *hostname = NULL, ip_addr[16];
void *p;
int error;
if (data == NULL) {
dprintk("%s: missing data argument\n", __FUNCTION__);
return -EINVAL;
}
if (data->version <= 0 || data->version > NFS4_MOUNT_VERSION) {
dprintk("%s: bad mount version\n", __FUNCTION__);
return -EINVAL;
}
/* We now require that the mount process passes the remote address */
if (data->host_addrlen != sizeof(addr))
return -EINVAL;
if (copy_from_user(&addr, data->host_addr, sizeof(addr)))
return -EFAULT;
if (addr.sin_family != AF_INET ||
addr.sin_addr.s_addr == INADDR_ANY
) {
dprintk("%s: mount program didn't pass remote IP address!\n",
__FUNCTION__);
return -EINVAL;
}
/* RFC3530: The default port for NFS is 2049 */
if (addr.sin_port == 0)
addr.sin_port = htons(NFS_PORT);
/* Grab the authentication type */
authflavour = RPC_AUTH_UNIX;
if (data->auth_flavourlen != 0) {
if (data->auth_flavourlen != 1) {
dprintk("%s: Invalid number of RPC auth flavours %d.\n",
__FUNCTION__, data->auth_flavourlen);
error = -EINVAL;
goto out_err_noserver;
}
if (copy_from_user(&authflavour, data->auth_flavours,
sizeof(authflavour))) {
error = -EFAULT;
goto out_err_noserver;
}
}
p = nfs_copy_user_string(NULL, &data->hostname, 256);
if (IS_ERR(p))
goto out_err;
hostname = p;
p = nfs_copy_user_string(NULL, &data->mnt_path, 1024);
if (IS_ERR(p))
goto out_err;
mntpath = p;
dprintk("MNTPATH: %s\n", mntpath);
p = nfs_copy_user_string(ip_addr, &data->client_addr,
sizeof(ip_addr) - 1);
if (IS_ERR(p))
goto out_err;
/* Get a volume representation */
server = nfs4_create_server(data, hostname, &addr, mntpath, ip_addr,
authflavour, &mntfh);
if (IS_ERR(server)) {
error = PTR_ERR(server);
goto out_err_noserver;
}
/* Get a superblock - note that we may end up sharing one that already exists */
s = sget(fs_type, nfs_compare_super, nfs_set_super, server);
if (IS_ERR(s)) {
error = PTR_ERR(s);
goto out_free;
}
if (s->s_fs_info != server) {
nfs_free_server(server);
server = NULL;
}
if (!s->s_root) {
/* initial superblock/root creation */
s->s_flags = flags;
nfs4_fill_super(s);
}
mntroot = nfs4_get_root(s, &mntfh);
if (IS_ERR(mntroot)) {
error = PTR_ERR(mntroot);
goto error_splat_super;
}
s->s_flags |= MS_ACTIVE;
mnt->mnt_sb = s;
mnt->mnt_root = mntroot;
kfree(mntpath);
kfree(hostname);
return 0;
out_err:
error = PTR_ERR(p);
goto out_err_noserver;
out_free:
nfs_free_server(server);
out_err_noserver:
kfree(mntpath);
kfree(hostname);
return error;
error_splat_super:
up_write(&s->s_umount);
deactivate_super(s);
goto out_err_noserver;
}
static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
const char *dev_name, void *data)
{
struct super_block *sb = NULL;
struct inode *inode = NULL;
struct dentry *root = NULL;
struct v9fs_session_info *v9ses = NULL;
int mode = S_IRWXUGO | S_ISVTX;
struct p9_fid *fid;
int retval = 0;
P9_DPRINTK(P9_DEBUG_VFS, " \n");
v9ses = kzalloc(sizeof(struct v9fs_session_info), GFP_KERNEL);
if (!v9ses)
return ERR_PTR(-ENOMEM);
fid = v9fs_session_init(v9ses, dev_name, data);
if (IS_ERR(fid)) {
retval = PTR_ERR(fid);
/*
* we need to call session_close to tear down some
* of the data structure setup by session_init
*/
goto close_session;
}
sb = sget(fs_type, NULL, v9fs_set_super, v9ses);
if (IS_ERR(sb)) {
retval = PTR_ERR(sb);
goto clunk_fid;
}
v9fs_fill_super(sb, v9ses, flags, data);
if (v9ses->cache)
sb->s_d_op = &v9fs_cached_dentry_operations;
else
sb->s_d_op = &v9fs_dentry_operations;
inode = v9fs_get_inode(sb, S_IFDIR | mode);
if (IS_ERR(inode)) {
retval = PTR_ERR(inode);
goto release_sb;
}
root = d_make_root(inode);
if (!root) {
retval = -ENOMEM;
goto release_sb;
}
sb->s_root = root;
if (v9fs_proto_dotl(v9ses)) {
struct p9_stat_dotl *st = NULL;
st = p9_client_getattr_dotl(fid, P9_STATS_BASIC);
if (IS_ERR(st)) {
retval = PTR_ERR(st);
goto release_sb;
}
root->d_inode->i_ino = v9fs_qid2ino(&st->qid);
v9fs_stat2inode_dotl(st, root->d_inode);
kfree(st);
} else {
struct p9_wstat *st = NULL;
st = p9_client_stat(fid);
if (IS_ERR(st)) {
retval = PTR_ERR(st);
goto release_sb;
}
root->d_inode->i_ino = v9fs_qid2ino(&st->qid);
v9fs_stat2inode(st, root->d_inode, sb);
p9stat_free(st);
kfree(st);
}
retval = v9fs_get_acl(inode, fid);
if (retval)
goto release_sb;
v9fs_fid_add(root, fid);
P9_DPRINTK(P9_DEBUG_VFS, " simple set mount, return 0\n");
return dget(sb->s_root);
clunk_fid:
p9_client_clunk(fid);
close_session:
v9fs_session_close(v9ses);
kfree(v9ses);
return ERR_PTR(retval);
release_sb:
/*
* we will do the session_close and root dentry release
* in the below call. But we need to clunk fid, because we haven't
* attached the fid to dentry so it won't get clunked
* automatically.
*/
p9_client_clunk(fid);
deactivate_locked_super(sb);
return ERR_PTR(retval);
}
/*
* Clone an NFS4 server record on xdev traversal (FSID-change)
*/
static int nfs4_xdev_get_sb(struct file_system_type *fs_type, int flags,
const char *dev_name, void *raw_data,
struct vfsmount *mnt)
{
struct nfs_clone_mount *data = raw_data;
struct super_block *s;
struct nfs_server *server;
struct dentry *mntroot;
int error;
dprintk("--> nfs4_xdev_get_sb()\n");
/* create a new volume representation */
server = nfs_clone_server(NFS_SB(data->sb), data->fh, data->fattr);
if (IS_ERR(server)) {
error = PTR_ERR(server);
goto out_err_noserver;
}
/* Get a superblock - note that we may end up sharing one that already exists */
s = sget(&nfs_fs_type, nfs_compare_super, nfs_set_super, server);
if (IS_ERR(s)) {
error = PTR_ERR(s);
goto out_err_nosb;
}
if (s->s_fs_info != server) {
nfs_free_server(server);
server = NULL;
}
if (!s->s_root) {
/* initial superblock/root creation */
s->s_flags = flags;
nfs4_clone_super(s, data->sb);
}
mntroot = nfs4_get_root(s, data->fh);
if (IS_ERR(mntroot)) {
error = PTR_ERR(mntroot);
goto error_splat_super;
}
s->s_flags |= MS_ACTIVE;
mnt->mnt_sb = s;
mnt->mnt_root = mntroot;
dprintk("<-- nfs4_xdev_get_sb() = 0\n");
return 0;
out_err_nosb:
nfs_free_server(server);
out_err_noserver:
dprintk("<-- nfs4_xdev_get_sb() = %d [error]\n", error);
return error;
error_splat_super:
up_write(&s->s_umount);
deactivate_super(s);
dprintk("<-- nfs4_xdev_get_sb() = %d [splat]\n", error);
return error;
}
void
conv(register FILE *fp)
{
register int c, k;
int m, n, n1, m1;
char str[4096], buf[4096];
while ((c = getc(fp)) != EOF) {
switch (c) {
case '\n': /* when input is text */
case ' ':
case 0: /* occasional noise creeps in */
break;
case '{': /* push down current environment */
t_push();
break;
case '}':
t_pop();
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
/* two motion digits plus a character */
hmot((c-'0')*10 + getc(fp)-'0');
put1(getc(fp));
break;
case 'c': /* single ascii character */
put1(getc(fp));
break;
case 'C':
sget(str, sizeof str, fp);
put1s(str);
break;
case 't': /* straight text */
fgets(buf, sizeof(buf), fp);
t_text(buf);
break;
case 'D': /* draw function */
fgets(buf, sizeof(buf), fp);
switch (buf[0]) {
case 'l': /* draw a line */
sscanf(buf+1, "%d %d", &n, &m);
drawline(n, m, ".");
break;
case 'c': /* circle */
sscanf(buf+1, "%d", &n);
drawcirc(n);
break;
case 'e': /* ellipse */
sscanf(buf+1, "%d %d", &m, &n);
drawellip(m, n);
break;
case 'a': /* arc */
sscanf(buf+1, "%d %d %d %d", &n, &m, &n1, &m1);
drawarc(n, m, n1, m1);
break;
case '~': /* wiggly line */
drawwig(buf+1);
break;
default:
error(FATAL, "unknown drawing function %s\n", buf);
break;
}
break;
case 's':
fscanf(fp, "%d", &n);
if (n == -23) {
float f;
fscanf(fp, "%f", &f);
setsize(f);
} else
setsize(t_size(n));/* ignore fractional sizes */
break;
case 'f':
sget(str, sizeof str, fp);
setfont(t_font(str));
break;
case 'H': /* absolute horizontal motion */
/* fscanf(fp, "%d", &n); */
while ((c = getc(fp)) == ' ')
;
k = 0;
do {
k = 10 * k + c - '0';
} while (isdigit(c = getc(fp)));
ungetc(c, fp);
hgoto(k);
break;
case 'h': /* relative horizontal motion */
/* fscanf(fp, "%d", &n); */
while ((c = getc(fp)) == ' ')
;
k = 0;
do {
k = 10 * k + c - '0';
} while (isdigit(c = getc(fp)));
ungetc(c, fp);
hmot(k);
break;
case 'w': /* word space */
putc(' ', stdout);
break;
case 'V':
fscanf(fp, "%d", &n);
vgoto(n);
break;
case 'v':
fscanf(fp, "%d", &n);
vmot(n);
break;
case 'p': /* new page */
fscanf(fp, "%d", &n);
t_page(n);
break;
case 'n': /* end of line */
while (getc(fp) != '\n')
;
t_newline();
break;
case '#': /* comment */
while (getc(fp) != '\n')
;
break;
case 'x': /* device control */
devcntrl(fp);
break;
default:
error(!FATAL, "unknown input character %o %c\n", c, c);
done();
}
}
}
/*
* once the super is inserted into the list by sget, s_umount
* will protect the lockfs code from trying to start a snapshot
* while we are mounting
*/
down(&sd.bdev->bd_mount_sem);
if (!sd.cno &&
(err = test_exclusive_mount(fs_type, sd.bdev, flags ^ MS_RDONLY))) {
err = (err < 0) ? : -EBUSY;
goto failed_unlock;
}
/*
* Phase-1: search any existent instance and get the_nilfs
*/
s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, &sd);
if (IS_ERR(s))
goto error_s;
if (!s->s_root) {
err = -ENOMEM;
nilfs = alloc_nilfs(sd.bdev);
if (!nilfs)
goto cancel_new;
} else {
struct nilfs_sb_info *sbi = NILFS_SB(s);
/*
* s_umount protects super_block from unmount process;
* It covers pointers of nilfs_sb_info and the_nilfs.
*/
/*
* Find a superblock for the given device / mount point.
*
* Note: This is based on get_sb_bdev from fs/super.c with a few additions
* for multiple device setup. Make sure to keep it in sync.
*/
static int btrfs_get_sb(struct file_system_type *fs_type, int flags,
const char *dev_name, void *data, struct vfsmount *mnt)
{
char *subvol_name = NULL;
struct block_device *bdev = NULL;
struct super_block *s;
struct dentry *root;
struct btrfs_fs_devices *fs_devices = NULL;
fmode_t mode = FMODE_READ;
int error = 0;
if (!(flags & MS_RDONLY))
mode |= FMODE_WRITE;
error = btrfs_parse_early_options(data, mode, fs_type,
&subvol_name, &fs_devices);
if (error)
return error;
error = btrfs_scan_one_device(dev_name, mode, fs_type, &fs_devices);
if (error)
goto error_free_subvol_name;
error = btrfs_open_devices(fs_devices, mode, fs_type);
if (error)
goto error_free_subvol_name;
if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
error = -EACCES;
goto error_close_devices;
}
bdev = fs_devices->latest_bdev;
s = sget(fs_type, btrfs_test_super, set_anon_super, fs_devices);
if (IS_ERR(s))
goto error_s;
if (s->s_root) {
if ((flags ^ s->s_flags) & MS_RDONLY) {
up_write(&s->s_umount);
deactivate_super(s);
error = -EBUSY;
goto error_close_devices;
}
btrfs_close_devices(fs_devices);
} else {
char b[BDEVNAME_SIZE];
s->s_flags = flags;
strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
error = btrfs_fill_super(s, fs_devices, data,
flags & MS_SILENT ? 1 : 0);
if (error) {
up_write(&s->s_umount);
deactivate_super(s);
goto error_free_subvol_name;
}
btrfs_sb(s)->fs_info->bdev_holder = fs_type;
s->s_flags |= MS_ACTIVE;
}
if (!strcmp(subvol_name, "."))
root = dget(s->s_root);
else {
mutex_lock(&s->s_root->d_inode->i_mutex);
root = lookup_one_len(subvol_name, s->s_root,
strlen(subvol_name));
mutex_unlock(&s->s_root->d_inode->i_mutex);
if (IS_ERR(root)) {
up_write(&s->s_umount);
deactivate_super(s);
error = PTR_ERR(root);
goto error_free_subvol_name;
}
if (!root->d_inode) {
dput(root);
up_write(&s->s_umount);
deactivate_super(s);
error = -ENXIO;
goto error_free_subvol_name;
}
}
mnt->mnt_sb = s;
mnt->mnt_root = root;
kfree(subvol_name);
return 0;
error_s:
error = PTR_ERR(s);
error_close_devices:
btrfs_close_devices(fs_devices);
error_free_subvol_name:
kfree(subvol_name);
return error;
}
static struct dentry *
cifs_do_mount(struct file_system_type *fs_type,
int flags, const char *dev_name, void *data)
{
int rc;
struct super_block *sb;
struct cifs_sb_info *cifs_sb;
struct smb_vol *volume_info;
struct cifs_mnt_data mnt_data;
struct dentry *root;
cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
volume_info = cifs_get_volume_info((char *)data, dev_name);
if (IS_ERR(volume_info))
return ERR_CAST(volume_info);
cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
if (cifs_sb == NULL) {
root = ERR_PTR(-ENOMEM);
goto out_nls;
}
cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
if (cifs_sb->mountdata == NULL) {
root = ERR_PTR(-ENOMEM);
goto out_cifs_sb;
}
cifs_setup_cifs_sb(volume_info, cifs_sb);
rc = cifs_mount(cifs_sb, volume_info);
if (rc) {
if (!(flags & MS_SILENT))
cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
rc);
root = ERR_PTR(rc);
goto out_mountdata;
}
mnt_data.vol = volume_info;
mnt_data.cifs_sb = cifs_sb;
mnt_data.flags = flags;
/* BB should we make this contingent on mount parm? */
flags |= MS_NODIRATIME | MS_NOATIME;
sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
if (IS_ERR(sb)) {
root = ERR_CAST(sb);
cifs_umount(cifs_sb);
goto out;
}
if (sb->s_root) {
cifs_dbg(FYI, "Use existing superblock\n");
cifs_umount(cifs_sb);
} else {
rc = cifs_read_super(sb);
if (rc) {
root = ERR_PTR(rc);
goto out_super;
}
sb->s_flags |= MS_ACTIVE;
}
root = cifs_get_root(volume_info, sb);
if (IS_ERR(root))
goto out_super;
cifs_dbg(FYI, "dentry root is: %p\n", root);
goto out;
out_super:
deactivate_locked_super(sb);
out:
cifs_cleanup_volume_info(volume_info);
return root;
out_mountdata:
kfree(cifs_sb->mountdata);
out_cifs_sb:
kfree(cifs_sb);
out_nls:
unload_nls(volume_info->local_nls);
goto out;
}
void p_f_iles(void)
{
print_at(2,2);
printf("3. DEMO: Filehandling\n");
print_at(2,4);
printf(" Fileselectorbox, Alertbox, Auslesen eines Files, RELSEEK, SEEK, LOF, LOC ..\n");
bild_char = sget(bild_char);
chdrive(1);
msprintf(a_char,"*.LST");
msprintf(b_char,"A:\\GFA_TEST\\");
chdir( b_char);
fileselect(mstrcat( b_char,a_char),a_char,c_char);
sput( bild_char);
if(strcmp(c_char,""))
{
if((FP[1] = fopen(c_char,"r")) == NULL)
{
printf("\nFehler beim �ffnen der Datei !");
getchar();
r_aus(-1);
}
c_long=lof(FP[1]);
msprintf(c_char,"%s",mid(c_char,rinstr(c_char,"\\")+1,-1));
print_at(5,6);
printf("L�nge der Datei %c%s%c%s: %ld\n",*chr(34),c_char,*chr(34),space(15-strlen(c_char)),c_long);
relseek(FP[1],10);
print_at(5,7);
printf("Suche Position : %ld\n",loc(FP[1]));
relseek(FP[1],10);
print_at(5,8);
printf("Erh�he den Filepointer um 10 Byte: %ld\n",loc(FP[1]));
seek(FP[1],10);
print_at(5,9);
printf("Stelle den Pointer auf Position : %ld\n",loc(FP[1]));
print_at(5,11);
printf("Auslesen und Anzeigen der Datei >>%s<< (Stop/Abbruch: Taste)\n",c_char);
p_s_top();
printf("\33E");
do
{
printf("%c", *chr(fgetc(FP[1])));
if(strcmp(inkey(),""))
{
a_lert( 2,"Abbruch",2,"JA|NEIN",back_long);
if(back_long==1)
{
goto raus;
}
}
if(feof(FP[1]))
goto M2;
}
while(1);
M2:
raus:
print_at(5,25);
printf("Ausgelesen bis Position: %ld%s\n",loc(FP[1]),space(54-strlen(ltoab(loc(FP[1]),-1,-1))));
fclose(FP[1]);
}
else
{
print_at(5,6);
printf("Sie haben keine Datei ausgew�hlt!\n");
}
p_s_top();
printf("\33E");
}
static void diag(const char *exe)
{
static const uint8_t elf[] = {0x7f, 'E', 'L', 'F'};
static const uint8_t shebang[] = {'#','!'};
static int diag_depth;
struct stat st;
const uint8_t *mm;
const char *itrp = NULL;
map_file(exe, PROT_READ, MAP_SHARED, &st, (void **)&mm);
exit_if(!((S_IXUSR|S_IXGRP|S_IXOTH) & st.st_mode),
"\"%s\" is not executable", exe)
if(st.st_size >= sizeof(shebang) &&
!memcmp(mm, shebang, sizeof(shebang))) {
const uint8_t *nl;
int maxlen = MIN(PATH_MAX, st.st_size - sizeof(shebang));
/* TODO(vc): EOF-terminated shebang lines are technically possible */
exit_if(!(nl = memchr(&mm[sizeof(shebang)], '\n', maxlen)),
"Shebang line too long");
pexit_if(!(itrp = strndup((char *)&mm[sizeof(shebang)], (nl - mm) - 2)),
"Failed to dup interpreter path");
} else if(st.st_size >= sizeof(elf) &&
!memcmp(mm, elf, sizeof(elf))) {
uint64_t (*lget)(const uint8_t *) = NULL;
uint32_t (*iget)(const uint8_t *) = NULL;
uint16_t (*sget)(const uint8_t *) = NULL;
const void *phoff = NULL, *phesz = NULL, *phecnt = NULL;
const uint8_t *ph = NULL;
int i, phreloff, phrelsz;
exit_if(mm[ELF_VERSION] != 1,
"Unsupported ELF version: %hhx", mm[ELF_VERSION]);
/* determine which accessors to use and where */
if(mm[ELF_BITS] == ELF_BITS_32) {
if(mm[ELF_ENDIAN] == ELF_ENDIAN_LITL) {
lget = le32_lget;
sget = le_sget;
iget = le_iget;
} else if(mm[ELF_ENDIAN] == ELF_ENDIAN_BIG) {
lget = be32_lget;
sget = be_sget;
iget = be_iget;
}
phoff = &mm[ELF32_PHT_OFF];
phesz = &mm[ELF32_PHTE_SIZE];
phecnt = &mm[ELF32_PHTE_CNT];
phreloff = ELF32_PHE_OFF;
phrelsz = ELF32_PHE_SIZE;
} else if(mm[ELF_BITS] == ELF_BITS_64) {
if(mm[ELF_ENDIAN] == ELF_ENDIAN_LITL) {
lget = le64_lget;
sget = le_sget;
iget = le_iget;
} else if(mm[ELF_ENDIAN] == ELF_ENDIAN_BIG) {
lget = be64_lget;
sget = be_sget;
iget = be_iget;
}
phoff = &mm[ELF64_PHT_OFF];
phesz = &mm[ELF64_PHTE_SIZE];
phecnt = &mm[ELF64_PHTE_CNT];
phreloff = ELF64_PHE_OFF;
phrelsz = ELF64_PHE_SIZE;
}
exit_if(!lget, "Unsupported ELF format");
if(!phoff) /* program header may be absent, don't make it an error */
return;
/* TODO(vc): sanity checks on values before using them */
for(ph = &mm[lget(phoff)], i = 0; i < sget(phecnt); i++, ph += sget(phesz)) {
if(iget(ph) == ELF_PT_INTERP) {
itrp = strndup((char *)&mm[lget(&ph[phreloff])], lget(&ph[phrelsz]));
break;
}
}
} else {
exit_if(1, "Unsupported file type");
}
exit_if(!itrp, "Unable to determine interpreter for \"%s\"", exe);
exit_if(*itrp != '/', "Path must be absolute: \"%s\"", itrp);
exit_if(++diag_depth > MAX_DIAG_DEPTH,
"Excessive interpreter recursion, giving up");
diag(itrp);
}
static struct super_block *v9fs_get_sb(struct file_system_type
*fs_type, int flags,
const char *dev_name, void *data)
{
struct super_block *sb = NULL;
struct v9fs_fcall *fcall = NULL;
struct inode *inode = NULL;
struct dentry *root = NULL;
struct v9fs_session_info *v9ses = NULL;
struct v9fs_fid *root_fid = NULL;
int mode = S_IRWXUGO | S_ISVTX;
uid_t uid = current->fsuid;
gid_t gid = current->fsgid;
int stat_result = 0;
int newfid = 0;
int retval = 0;
dprintk(DEBUG_VFS, " \n");
v9ses = kzalloc(sizeof(struct v9fs_session_info), GFP_KERNEL);
if (!v9ses)
return ERR_PTR(-ENOMEM);
if ((newfid = v9fs_session_init(v9ses, dev_name, data)) < 0) {
dprintk(DEBUG_ERROR, "problem initiating session\n");
sb = ERR_PTR(newfid);
goto out_free_session;
}
sb = sget(fs_type, NULL, v9fs_set_super, v9ses);
if (IS_ERR(sb))
goto out_close_session;
v9fs_fill_super(sb, v9ses, flags);
inode = v9fs_get_inode(sb, S_IFDIR | mode);
if (IS_ERR(inode)) {
retval = PTR_ERR(inode);
goto put_back_sb;
}
inode->i_uid = uid;
inode->i_gid = gid;
root = d_alloc_root(inode);
if (!root) {
retval = -ENOMEM;
goto put_back_sb;
}
sb->s_root = root;
stat_result = v9fs_t_stat(v9ses, newfid, &fcall);
if (stat_result < 0) {
dprintk(DEBUG_ERROR, "stat error\n");
v9fs_t_clunk(v9ses, newfid);
} else {
/* Setup the Root Inode */
root_fid = v9fs_fid_create(v9ses, newfid);
if (root_fid == NULL) {
retval = -ENOMEM;
goto put_back_sb;
}
retval = v9fs_fid_insert(root_fid, root);
if (retval < 0) {
kfree(fcall);
goto put_back_sb;
}
root_fid->qid = fcall->params.rstat.stat.qid;
root->d_inode->i_ino =
v9fs_qid2ino(&fcall->params.rstat.stat.qid);
v9fs_stat2inode(&fcall->params.rstat.stat, root->d_inode, sb);
}
kfree(fcall);
if (stat_result < 0) {
retval = stat_result;
goto put_back_sb;
}
return sb;
out_close_session:
v9fs_session_close(v9ses);
out_free_session:
kfree(v9ses);
return sb;
put_back_sb:
/* deactivate_super calls v9fs_kill_super which will frees the rest */
up_write(&sb->s_umount);
deactivate_super(sb);
return ERR_PTR(retval);
}
