int main( int argc, char **argv ) { int err; int existingdirents=-1; #if defined(CYGSEM_FILEIO_BLOCK_USAGE) struct cyg_fs_block_usage usage; #endif CYG_TEST_INIT(); // -------------------------------------------------------------- err = mount( "/dev/disk0/1", "/", "fatfs" ); if( err < 0 ) SHOW_RESULT( mount, err ); err = chdir( "/" ); if( err < 0 ) SHOW_RESULT( chdir, err ); checkcwd( "/" ); listdir( "/", true, -1, &existingdirents ); // -------------------------------------------------------------- #if defined(CYGSEM_FILEIO_BLOCK_USAGE) err = cyg_fs_getinfo("/", FS_INFO_BLOCK_USAGE, &usage, sizeof(usage)); if( err < 0 ) SHOW_RESULT( cyg_fs_getinfo, err ); diag_printf("<INFO>: total size: %6lld blocks, %10lld bytes\n", usage.total_blocks, usage.total_blocks * usage.block_size); diag_printf("<INFO>: free size: %6lld blocks, %10lld bytes\n", usage.free_blocks, usage.free_blocks * usage.block_size); diag_printf("<INFO>: block size: %6u bytes\n", usage.block_size); #endif // -------------------------------------------------------------- createfile( "/foo", 20257 ); checkfile( "foo" ); copyfile( "foo", "fee"); checkfile( "fee" ); comparefiles( "foo", "/fee" ); diag_printf("<INFO>: mkdir bar\n"); err = mkdir( "/bar", 0 ); if( err < 0 ) SHOW_RESULT( mkdir, err ); listdir( "/" , true, existingdirents+3, NULL ); copyfile( "fee", "/bar/fum" ); checkfile( "bar/fum" ); comparefiles( "/fee", "bar/fum" ); diag_printf("<INFO>: cd bar\n"); err = chdir( "bar" ); if( err < 0 ) SHOW_RESULT( chdir, err ); checkcwd( "/bar" ); diag_printf("<INFO>: rename /foo bundy\n"); err = rename( "/foo", "bundy" ); if( err < 0 ) SHOW_RESULT( rename, err ); listdir( "/", true, existingdirents+2, NULL ); listdir( "" , true, 4, NULL ); checkfile( "/bar/bundy" ); comparefiles("/fee", "bundy" ); #if defined(CYGSEM_FILEIO_BLOCK_USAGE) err = cyg_fs_getinfo("/", FS_INFO_BLOCK_USAGE, &usage, sizeof(usage)); if( err < 0 ) SHOW_RESULT( cyg_fs_getinfo, err ); diag_printf("<INFO>: total size: %6lld blocks, %10lld bytes\n", usage.total_blocks, usage.total_blocks * usage.block_size); diag_printf("<INFO>: free size: %6lld blocks, %10lld bytes\n", usage.free_blocks, usage.free_blocks * usage.block_size); diag_printf("<INFO>: block size: %6u bytes\n", usage.block_size); #endif // -------------------------------------------------------------- diag_printf("<INFO>: unlink fee\n"); err = unlink( "/fee" ); if( err < 0 ) SHOW_RESULT( unlink, err ); diag_printf("<INFO>: unlink fum\n"); err = unlink( "fum" ); if( err < 0 ) SHOW_RESULT( unlink, err ); diag_printf("<INFO>: unlink /bar/bundy\n"); err = unlink( "/bar/bundy" ); if( err < 0 ) SHOW_RESULT( unlink, err ); diag_printf("<INFO>: cd /\n"); err = chdir( "/" ); if( err < 0 ) SHOW_RESULT( chdir, err ); checkcwd( "/" ); diag_printf("<INFO>: rmdir /bar\n"); err = rmdir( "/bar" ); if( err < 0 ) SHOW_RESULT( rmdir, err ); listdir( "/", false, existingdirents, NULL ); // -------------------------------------------------------------- #if 0 diag_printf("<INFO>: mkdir disk2\n"); err = mkdir( "/disk2", 0 ); if( err < 0 ) SHOW_RESULT( mkdir, err ); #else diag_printf("<INFO>: mount /disk2\n"); err = mount( "/dev/disk0/2", "/disk2", "fatfs" ); if( err < 0 ) SHOW_RESULT( mount, err ); #endif listdir( "/disk2" , true, -1, &existingdirents); createfile( "/disk2/tinky", 4567 ); copyfile( "/disk2/tinky", "/disk2/laalaa" ); checkfile( "/disk2/tinky"); checkfile( "/disk2/laalaa"); comparefiles( "/disk2/tinky", "/disk2/laalaa" ); diag_printf("<INFO>: cd /disk2\n"); err = chdir( "/disk2" ); if( err < 0 ) SHOW_RESULT( chdir, err ); checkcwd( "/disk2" ); diag_printf("<INFO>: mkdir noonoo\n"); err = mkdir( "noonoo", 0 ); if( err < 0 ) SHOW_RESULT( mkdir, err ); listdir( "/disk2" , true, existingdirents+3, NULL); diag_printf("<INFO>: cd noonoo\n"); err = chdir( "noonoo" ); if( err < 0 ) SHOW_RESULT( chdir, err ); checkcwd( "/disk2/noonoo" ); createfile( "tinky", 6789 ); checkfile( "tinky" ); createfile( "dipsy", 34567 ); checkfile( "dipsy" ); copyfile( "dipsy", "po" ); checkfile( "po" ); comparefiles( "dipsy", "po" ); listdir( ".", true, 5, NULL ); listdir( "", true, 5, NULL ); listdir( "..", true, existingdirents+3, NULL ); // -------------------------------------------------------------- diag_printf("<INFO>: unlink tinky\n"); err = unlink( "tinky" ); if( err < 0 ) SHOW_RESULT( unlink, err ); diag_printf("<INFO>: unlink dipsy\n"); err = unlink( "dipsy" ); if( err < 0 ) SHOW_RESULT( unlink, err ); diag_printf("<INFO>: unlink po\n"); err = unlink( "po" ); if( err < 0 ) SHOW_RESULT( unlink, err ); diag_printf("<INFO>: cd ..\n"); err = chdir( ".." ); if( err < 0 ) SHOW_RESULT( chdir, err ); checkcwd( "/disk2" ); diag_printf("<INFO>: rmdir noonoo\n"); err = rmdir( "noonoo" ); if( err < 0 ) SHOW_RESULT( rmdir, err ); // -------------------------------------------------------------- err = mkdir( "x", 0 ); if( err < 0 ) SHOW_RESULT( mkdir, err ); err = mkdir( "x/y", 0 ); if( err < 0 ) SHOW_RESULT( mkdir, err ); err = mkdir( "x/y/z", 0 ); if( err < 0 ) SHOW_RESULT( mkdir, err ); err = mkdir( "x/y/z/w", 0 ); if( err < 0 ) SHOW_RESULT( mkdir, err ); diag_printf("<INFO>: cd /disk2/x/y/z/w\n"); err = chdir( "/disk2/x/y/z/w" ); if( err < 0 ) SHOW_RESULT( chdir, err ); checkcwd( "/disk2/x/y/z/w" ); diag_printf("<INFO>: cd ..\n"); err = chdir( ".." ); if( err < 0 ) SHOW_RESULT( chdir, err ); checkcwd( "/disk2/x/y/z" ); diag_printf("<INFO>: cd .\n"); err = chdir( "." ); if( err < 0 ) SHOW_RESULT( chdir, err ); checkcwd( "/disk2/x/y/z" ); diag_printf("<INFO>: cd ../../y\n"); err = chdir( "../../y" ); if( err < 0 ) SHOW_RESULT( chdir, err ); checkcwd( "/disk2/x/y" ); diag_printf("<INFO>: cd ../..\n"); err = chdir( "../.." ); if( err < 0 ) SHOW_RESULT( chdir, err ); checkcwd( "/disk2" ); diag_printf("<INFO>: rmdir x/y/z/w\n"); err = rmdir( "x/y/z/w" ); if( err < 0 ) SHOW_RESULT( rmdir, err ); diag_printf("<INFO>: rmdir x/y/z\n"); err = rmdir( "x/y/z" ); if( err < 0 ) SHOW_RESULT( rmdir, err ); diag_printf("<INFO>: rmdir x/y\n"); err = rmdir( "x/y" ); if( err < 0 ) SHOW_RESULT( rmdir, err ); diag_printf("<INFO>: rmdir x\n"); err = rmdir( "x" ); if( err < 0 ) SHOW_RESULT( rmdir, err ); // -------------------------------------------------------------- checkcwd( "/disk2" ); diag_printf("<INFO>: unlink tinky\n"); err = unlink( "tinky" ); if( err < 0 ) SHOW_RESULT( unlink, err ); diag_printf("<INFO>: unlink laalaa\n"); err = unlink( "laalaa" ); if( err < 0 ) SHOW_RESULT( unlink, err ); diag_printf("<INFO>: cd /\n"); err = chdir( "/" ); if( err < 0 ) SHOW_RESULT( chdir, err ); checkcwd( "/" ); listdir( "/disk2", true, -1, NULL ); #if 0 diag_printf("<INFO>: rmdir dir\n"); err = rmdir( "disk2" ); if( err < 0 ) SHOW_RESULT( rmdir, err ); #else diag_printf("<INFO>: umount /disk2\n"); err = umount( "/disk2" ); if( err < 0 ) SHOW_RESULT( umount, err ); #endif #ifdef CYGCFG_FS_FAT_USE_ATTRIBUTES // Create file diag_printf("<INFO>: create /foo\n"); createfile( "/foo", 20257 ); // Verify it is created with archive bit set checkattrib( "/foo", S_FATFS_ARCHIVE ); // Make it System diag_printf("<INFO>: attrib -A+S /foo\n"); err = cyg_fs_set_attrib( "/foo", S_FATFS_SYSTEM ); if( err < 0 ) SHOW_RESULT( chmod system , err ); // Verify it is now System checkattrib( "/foo", S_FATFS_SYSTEM ); // Make it Hidden diag_printf("<INFO>: attrib -S+H /foo\n"); err = cyg_fs_set_attrib( "/foo", S_FATFS_HIDDEN ); if( err < 0 ) SHOW_RESULT( chmod system , err ); // Verify it is now Hidden checkattrib( "/foo", S_FATFS_HIDDEN ); // Make it Read-only diag_printf("<INFO>: attrib -H+R /foo\n"); err = cyg_fs_set_attrib( "/foo", S_FATFS_RDONLY ); if( err < 0 ) SHOW_RESULT( chmod system , err ); // Verify it is now Read-only checkattrib( "/foo", S_FATFS_RDONLY ); // Verify we cannot unlink a read-only file diag_printf("<INFO>: unlink /foo\n"); err = unlink( "/foo" ); if( (err != -1) || (errno != EPERM) ) SHOW_RESULT( unlink, err ); // Verify we cannot rename a read-only file diag_printf("<INFO>: rename /foo bundy\n"); err = rename( "/foo", "bundy" ); if( (err != -1) || (errno != EPERM) ) SHOW_RESULT( rename, err ); // Verify we cannot open read-only file for writing int fd; diag_printf("<INFO>: create file /foo\n"); fd = open( "/foo", O_WRONLY ); if( (err != -1) || (errno != EACCES) ) SHOW_RESULT( open, err ); if( err > 0 ) close(fd); // Make it Normal diag_printf("<INFO>: attrib -H /foo\n"); err = cyg_fs_set_attrib( "/foo", 0 ); if( err < 0 ) SHOW_RESULT( chmod none , err ); // Verify it is now nothing checkattrib( "/foo", 0 ); // Now delete our test file diag_printf("<INFO>: unlink /foo\n"); err = unlink( "/foo" ); if( err < 0 ) SHOW_RESULT( unlink, err ); #endif // CYGCFG_FS_FAT_USE_ATTRIBUTES maxfile("file.max"); listdir( "/", true, -1, NULL ); diag_printf("<INFO>: unlink file.max\n"); err = unlink( "file.max" ); if( err < 0 ) SHOW_RESULT( unlink, err ); diag_printf("<INFO>: umount /\n"); err = umount( "/" ); if( err < 0 ) SHOW_RESULT( umount, err ); CYG_TEST_PASS_FINISH("fatfs1"); }
int main( int argc, char **argv ) { int err; FILE *stream; long pos; unsigned int i; char header[3]; CYG_TEST_INIT(); // -------------------------------------------------------------- CYG_TEST_INFO("mount /"); err = mount( "", "/", "ramfs" ); if( err < 0 ) SHOW_RESULT( mount, err ); CYG_TEST_INFO("creating /fseek"); stream = fopen("/fseek","w+"); if (!stream) { SHOW_RESULT( fopen, NULL); CYG_TEST_FAIL_FINISH("done");\ } for (i = 0; i < sizeof(buf); i++) { buf[i] = i % 256; } CYG_TEST_INFO("writing test pattern"); err=fwrite(buf,sizeof(buf), 1, stream); if ( err < 0 ) SHOW_RESULT( fwrite, err ); pos = ftell(stream); if (pos < 0) SHOW_RESULT( ftell, pos ); if (pos != sizeof(buf)) diag_printf("<FAIL>: ftell is not telling the truth."); CYG_TEST_INFO("fseek()ing to 85"); err = fseek(stream, 85, SEEK_SET); if ( err < 0 ) SHOW_RESULT( fseek, err ); pos = ftell(stream); if (pos < 0) SHOW_RESULT( ftell, pos ); if (pos != 85) CYG_TEST_FAIL("ftell is not telling the truth"); err = fread(header,3,1,stream); if ( err < 0 ) SHOW_RESULT( fwrite, err ); if ((header[0] != 85) || (header[1] != 86) || (header[2] != 87)) CYG_TEST_FAIL("Read returned false data"); pos = ftell(stream); if (pos < 0) SHOW_RESULT( ftell, pos ); if (pos != 88) CYG_TEST_FAIL("ftell is not telling the truth"); for (i = 88; i < 161; i++) { buf[i] = 0x42; } CYG_TEST_INFO("writing"); err = fwrite(buf+88, 73, 1, stream); if ( err < 0 ) SHOW_RESULT( fwrite, err ); pos = ftell(stream); if (pos < 0) SHOW_RESULT( ftell, pos ); if (pos != 161) CYG_TEST_FAIL("ftell is not telling the truth"); CYG_TEST_INFO("closing file"); err = fclose(stream); if (err != 0) SHOW_RESULT( fclose, err ); CYG_TEST_INFO("open file /fseek"); stream = fopen("/fseek", "r+"); if (!stream) { SHOW_RESULT( fopen, NULL); CYG_TEST_FAIL_FINISH("done");\ } CYG_TEST_INFO("Seeking to beginning of file"); err = fseek(stream, 0, SEEK_SET); if ( err < 0 ) SHOW_RESULT( fseek, err ); CYG_TEST_INFO("Reading buf1"); err = fread(buf1,sizeof(buf1),1, stream); if (err != 1) SHOW_RESULT( fread, err ); CYG_TEST_INFO("Comparing contents"); if (memcmp(buf, buf1, sizeof(buf1))) CYG_TEST_FAIL("File contents inconsistent"); CYG_TEST_INFO("closing file"); err = fclose(stream); if (err != 0) SHOW_RESULT( fclose, err ); CYG_TEST_INFO("umount /"); err = umount( "/" ); if( err < 0 ) SHOW_RESULT( umount, err ); CYG_TEST_PASS_FINISH("ramfs3"); }
/** try to mount an initrd on mountpoint * @file: path to the initrd file * @mountpoint: the directory where we mount to */ int try_initrd_mount(char **file, const char *mountpoint) { struct stat st; int fd; unsigned long len,readed; char magic[6],buff[1024],*cpio_archive; if(stat(*file,&st)) return -1; if(S_ISREG(st.st_mode)) { cpio_archive=NULL; fd = open(*file,O_RDONLY); if(fd<0) return -1; if((len = read(fd,magic,6)) != 6) { close(fd); return -1; } // gzip magic if(magic[0] == 0x1f && magic[1] == 0x8b) { close(fd); cpio_archive = zlib_decompress_file(*file,&len); if(!cpio_archive) return -1; memcpy(magic,cpio_archive,6); } else // get file size { while((readed = read(fd,buff,1024)) > 0) len+=readed; close(fd); if(readed) return -1; } // cpio magic if(magic[0] == '0' && magic[1] == '7' && magic[2] == '0' && magic[3] == '7' && magic[4] == '0' && magic[5] == '7') { if(!cpio_archive) // we have to read it { cpio_archive = malloc(len); // len is the size in bytes ( man 2 read ) if(!cpio_archive) { return -1; } fd = open(*file,O_RDONLY); if(fd<0) { free(cpio_archive); return -1; } if((readed = read(fd,cpio_archive,len)) != len) { free(cpio_archive); close(fd); return -1; } close(fd); } umount(mountpoint); if(mount("tmpfs",mountpoint,"tmpfs",MS_RELATIME,"")) { free(cpio_archive); return -1; } if(cpio_copyin(cpio_archive,len,mountpoint)) { umount(mountpoint); free(cpio_archive); return -1; } free(cpio_archive); len = strlen(mountpoint); free(*file); *file = malloc((len+1)*sizeof(char)); if(!*file) { umount(mountpoint); return -1; } strncpy(*file,mountpoint,len); (*file)[len] = '\0'; } } return 0; }
int main(int ac, char **av) { int lc; /* loop counter */ char *msg; /* message returned from parse_opts */ /* parse standard options */ if ((msg = parse_opts(ac, av, options, &help)) != NULL) tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); /* Check for mandatory option of the testcase */ if (!Dflag) tst_brkm(TBROK, NULL, "you must specify the device used for mounting with the -D " "option"); if (Tflag) { Fstype = malloc(strlen(fstype) + 1); if (Fstype == NULL) { tst_brkm(TBROK|TERRNO, NULL, "malloc - failed to alloc %zd", strlen(fstype)); } strncpy(Fstype, fstype, strlen(fstype) + 1); } else { Fstype = malloc(strlen(DEFAULT_FSTYPE) + 1); if (Fstype == NULL) { tst_brkm(TBROK, NULL, "malloc - failed to alloc %zu", strlen(DEFAULT_FSTYPE)); } strncpy(Fstype, DEFAULT_FSTYPE, strlen(DEFAULT_FSTYPE) + 1); } if (STD_COPIES != 1) { tst_resm(TINFO, "-c option has no effect for this testcase - " "%s doesn't allow running more than one instance " "at a time", TCID); STD_COPIES = 1; } setup(); for (lc = 0; TEST_LOOPING(lc); lc++) { Tst_count = 0; /* Call mount(2) */ TEST(mount(device, mntpoint, Fstype, 0, NULL)); /* check return code */ if (TEST_RETURN != 0) { tst_resm(TFAIL|TTERRNO, "mount(2) failed"); } else { tst_resm(TPASS, "mount(2) passed "); TEST(umount(mntpoint)); if (TEST_RETURN != 0) { tst_brkm(TBROK|TTERRNO, cleanup, "umount(2) failed"); } } } /* cleanup and exit */ cleanup(); tst_exit(); }
/* When multiple fstab records share the same mount_point, it will * try to mount each one in turn, and ignore any duplicates after a * first successful mount. * Returns -1 on error, and FS_MGR_MNTALL_* otherwise. */ int fs_mgr_mount_all(struct fstab *fstab) { int i = 0; int encryptable = FS_MGR_MNTALL_DEV_NOT_ENCRYPTED; int error_count = 0; int mret = -1; int mount_errno = 0; int attempted_idx = -1; if (!fstab) { return -1; } for (i = 0; i < fstab->num_entries; i++) { /* Don't mount entries that are managed by vold */ if (fstab->recs[i].fs_mgr_flags & (MF_VOLDMANAGED | MF_RECOVERYONLY)) { continue; } /* Skip swap and raw partition entries such as boot, recovery, etc */ if (!strcmp(fstab->recs[i].fs_type, "swap") || !strcmp(fstab->recs[i].fs_type, "emmc") || !strcmp(fstab->recs[i].fs_type, "mtd")) { continue; } if (fstab->recs[i].fs_mgr_flags & MF_WAIT) { wait_for_file(fstab->recs[i].blk_device, WAIT_TIMEOUT); } if ((fstab->recs[i].fs_mgr_flags & MF_VERIFY) && !device_is_debuggable()) { wait_for_file("/dev/device-mapper", WAIT_TIMEOUT); if (fs_mgr_setup_verity(&fstab->recs[i]) < 0) { ERROR("Could not set up verified partition, skipping!\n"); continue; } } int last_idx_inspected; mret = mount_with_alternatives(fstab, i, &last_idx_inspected, &attempted_idx); i = last_idx_inspected; mount_errno = errno; /* Deal with encryptability. */ if (!mret) { /* If this is encryptable, need to trigger encryption */ if ((fstab->recs[attempted_idx].fs_mgr_flags & MF_FORCECRYPT)) { if (umount(fstab->recs[attempted_idx].mount_point) == 0) { if (encryptable == FS_MGR_MNTALL_DEV_NOT_ENCRYPTED) { ERROR("Will try to encrypt %s %s\n", fstab->recs[attempted_idx].mount_point, fstab->recs[attempted_idx].fs_type); encryptable = FS_MGR_MNTALL_DEV_NEEDS_ENCRYPTION; } else { ERROR("Only one encryptable/encrypted partition supported\n"); encryptable = FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED; } } else { INFO("Could not umount %s - allow continue unencrypted\n", fstab->recs[attempted_idx].mount_point); continue; } } /* Success! Go get the next one */ continue; } /* mount(2) returned an error, check if it's encryptable and deal with it */ if (mret && mount_errno != EBUSY && mount_errno != EACCES && fs_mgr_is_encryptable(&fstab->recs[attempted_idx])) { if(partition_wiped(fstab->recs[attempted_idx].blk_device)) { ERROR("%s(): %s is wiped and %s %s is encryptable. Suggest recovery...\n", __func__, fstab->recs[attempted_idx].blk_device, fstab->recs[attempted_idx].mount_point, fstab->recs[attempted_idx].fs_type); encryptable = FS_MGR_MNTALL_DEV_NEEDS_RECOVERY; continue; } else { /* Need to mount a tmpfs at this mountpoint for now, and set * properties that vold will query later for decrypting */ ERROR("%s(): possibly an encryptable blkdev %s for mount %s type %s )\n", __func__, fstab->recs[attempted_idx].blk_device, fstab->recs[attempted_idx].mount_point, fstab->recs[attempted_idx].fs_type); if (fs_mgr_do_tmpfs_mount(fstab->recs[attempted_idx].mount_point) < 0) { ++error_count; continue; } } encryptable = FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED; } else { ERROR("Failed to mount an un-encryptable or wiped partition on" "%s at %s options: %s error: %s\n", fstab->recs[attempted_idx].blk_device, fstab->recs[attempted_idx].mount_point, fstab->recs[attempted_idx].fs_options, strerror(mount_errno)); ++error_count; continue; } } if (error_count) { return -1; } else { return encryptable; } }
/** * li_run_env_setup_with_root: * * Setup a new environment to run the application in, * using a specific root filesystem. * This function prints errors to stderr at time. * * Returns: A path to the new root filesystem, or %NULL on error. */ gchar* li_run_env_setup_with_root (const gchar *root_fs) { int res = 0; gchar *fname = NULL; uid_t uid; int mount_count; g_autofree gchar *newroot = NULL; g_autofree gchar *approot_dir = NULL; /* perform some preparation before we can mount the app */ g_debug ("creating new namespace"); res = unshare (CLONE_NEWNS); if (res != 0) { g_printerr ("Failed to create new namespace: %s\n", strerror(errno)); return NULL; } /* Mark everything as slave, so that we still * receive mounts from the real root, but don't * propagate mounts to the real root. */ if (mount (NULL, root_fs, NULL, MS_SLAVE | MS_REC, NULL) < 0) { g_printerr ("Failed to make / slave.\n"); return NULL; } uid = getuid (); newroot = g_strdup_printf ("/run/user/%d/.limba-root", uid); if (g_mkdir_with_parents (newroot, 0755) != 0) { g_printerr ("Failed to create root tmpfs.\n"); return NULL; } /* Create a tmpfs which we will use as / in the namespace */ if (mount ("", newroot, "tmpfs", MS_NODEV | MS_NOEXEC | MS_NOSUID, NULL) != 0) { g_printerr ("Failed to mount tmpfs.\n"); return NULL; } /* build & bindmount the root filesystem */ if (mkdir_and_bindmount (newroot, root_fs, "/bin", FALSE) != 0) return NULL; if (mkdir_and_bindmount (newroot, root_fs, "/cdrom", FALSE) != 0) return NULL; if (mkdir_and_bindmount (newroot, root_fs, "/dev", FALSE) != 0) return NULL; if (mkdir_and_bindmount (newroot, root_fs, "/etc", FALSE) != 0) return NULL; if (mkdir_and_bindmount (newroot, root_fs, "/home", FALSE) != 0) return NULL; if (mkdir_and_bindmount (newroot, root_fs, "/lib", FALSE) != 0) return NULL; if (mkdir_and_bindmount (newroot, root_fs, "/lib64", FALSE) != 0) return NULL; if (mkdir_and_bindmount (newroot, root_fs, "/media", TRUE) != 0) return NULL; if (mkdir_and_bindmount (newroot, root_fs, "/mnt", TRUE) != 0) return NULL; if (mkdir_and_bindmount (newroot, root_fs, "/opt", FALSE) != 0) return NULL; if (mkdir_and_bindmount (newroot, root_fs, "/proc", FALSE) != 0) return NULL; if (mkdir_and_bindmount (newroot, root_fs, "/srv", FALSE) != 0) return NULL; if (mkdir_and_bindmount (newroot, root_fs, "/sys", FALSE) != 0) return NULL; if (mkdir_and_bindmount (newroot, root_fs, "/usr", FALSE) != 0) return NULL; if (mkdir_and_bindmount (newroot, root_fs, "/var", TRUE) != 0) return NULL; /* prepare /run - give access to session data and DBus system bus */ fname = g_strdup_printf ("/run/user/%d/", uid); if (mkdir_and_bindmount (newroot, root_fs, fname, TRUE) != 0) { g_free (fname); return NULL; } g_free (fname); if (mkdir_and_bindmount (newroot, root_fs, "/run/dbus", TRUE) != 0) return NULL; fname = g_build_filename (newroot, "tmp", NULL); if (g_mkdir_with_parents (fname, 0755) != 0) { g_free (fname); g_printerr ("Unable to create root /tmp dir.\n"); return NULL; } if (chmod (fname, 01777) != 0) { g_free (fname); g_printerr ("Unable to set permissions on /tmp dir.\n"); return NULL; } g_free (fname); fname = g_build_filename (newroot, ".oldroot", NULL); if (g_mkdir_with_parents (fname, 0755) != 0) { g_free (fname); g_printerr ("Unable to create root /.oldroot dir.\n"); return NULL; } g_free (fname); /* the place where we will mount the application data to */ approot_dir = g_build_filename (newroot, "app", NULL); if (g_mkdir_with_parents (approot_dir, 0755) != 0) { g_printerr ("Unable to create /app dir.\n"); return NULL; } g_debug ("mount (private)"); mount_count = 0; res = mount (approot_dir, approot_dir, NULL, MS_PRIVATE, NULL); if (res != 0 && errno == EINVAL) { /* Maybe if failed because there is no mount * to be made private at that point, lets * add a bind mount there. */ g_debug (("mount (bind)\n")); res = mount (approot_dir, approot_dir, NULL, MS_BIND, NULL); /* And try again */ if (res == 0) { mount_count++; /* Bind mount succeeded */ g_debug ("mount (private)"); res = mount (approot_dir, approot_dir, NULL, MS_PRIVATE, NULL); } } if (res != 0) { g_error ("Failed to make prefix namespace private"); goto error_out; } return g_strdup (newroot); error_out: /* we have an error */ while (mount_count-- > 0) umount (approot_dir); return NULL; }
int main(int argc, char *argv[]) { int i, res; static char *const cmd[] = { "/init", NULL }; struct fstab *fstab = NULL; for(i = 1; i < argc; ++i) { if(strcmp(argv[i], "-v") == 0) { printf("%d\n", VERSION_TRAMPOLINE); fflush(stdout); return 0; } } umask(000); // Init only the little we need, leave the rest for real init mkdir("/dev", 0755); mkdir("/dev/pts", 0755); mkdir("/dev/socket", 0755); mkdir("/proc", 0755); mkdir("/sys", 0755); mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755"); mount("devpts", "/dev/pts", "devpts", 0, NULL); mount("proc", "/proc", "proc", 0, NULL); mount("sysfs", "/sys", "sysfs", 0, NULL); klog_init(); ERROR("Running trampoline v%d\n", VERSION_TRAMPOLINE); if(is_charger_mode()) { ERROR("Charger mode detected, skipping multirom\n"); goto run_main_init; } #if MR_DEVICE_HOOKS >= 3 tramp_hook_before_device_init(); #endif ERROR("Initializing devices..."); devices_init(); ERROR("Done initializing"); if(wait_for_file("/dev/graphics/fb0", 5) < 0) { ERROR("Waiting too long for fb0"); goto exit; } fstab = fstab_auto_load(); if(!fstab) goto exit; #if 0 fstab_dump(fstab); //debug #endif // mount and run multirom from sdcard mount_and_run(fstab); exit: if(fstab) fstab_destroy(fstab); // close and destroy everything devices_close(); run_main_init: if(access(KEEP_REALDATA, F_OK) < 0) { umount(REALDATA); umount("/dev/pts"); umount("/dev"); rmdir("/dev/pts"); rmdir("/dev/socket"); rmdir("/dev"); rmdir(REALDATA); } umount("/proc"); umount("/sys"); rmdir("/proc"); rmdir("/sys"); ERROR("Running main_init\n"); fixup_symlinks(); chmod("/main_init", EXEC_MASK); rename("/main_init", "/init"); res = execve(cmd[0], cmd, NULL); ERROR("execve returned %d %d %s\n", res, errno, strerror(errno)); return 0; }
void start_kernel(struct params_t *params, int choice) { /* we use var[] instead of *var because sizeof(var) using */ #ifdef USE_HOST_DEBUG const char kexec_path[] = "/bin/echo"; #else const char kexec_path[] = KEXEC_PATH; #endif const char mount_point[] = MOUNTPOINT; const char str_cmdline_start[] = "--command-line=root="; const char str_rootfstype[] = " rootfstype="; const char str_rootwait[] = " rootwait"; const char str_ubirootdev[] = "ubi0"; const char str_ubimtd[] = " ubi.mtd="; /* max ' ubi.mtd=15' len 11 +1 = 12 */ #ifdef UBI_VID_HDR_OFFSET const char str_ubimtd_off[] = UBI_VID_HDR_OFFSET; #else const char str_ubimtd_off[] = ""; #endif char mount_dev[16]; char mount_fstype[16]; char str_mtd_id[3]; /* Tags passed from host kernel cmdline to kexec'ed kernel */ const char str_mtdparts[] = " mtdparts="; const char str_fbcon[] = " fbcon="; const char str_initrd_start[] = "--initrd="; /* empty environment */ char *const envp[] = { NULL }; const char *load_argv[] = { NULL, "-l", NULL, NULL, NULL, NULL }; const char *exec_argv[] = { NULL, "-e", NULL, NULL}; char *cmdline_arg = NULL, *initrd_arg = NULL; int n, idx, u; struct stat sinfo; struct boot_item_t *item; item = params->bootcfg->list[choice]; exec_argv[0] = kexec_path; load_argv[0] = kexec_path; /* --command-line arg generation */ idx = 2; /* load_argv current option index */ /* fill '--command-line' option */ if (item->device) { /* default device to mount */ strcpy(mount_dev, item->device); /* allocate space */ n = sizeof(str_cmdline_start) + strlen(item->device) + sizeof(str_ubirootdev) + 2 + sizeof(str_ubimtd) + 2 + sizeof(str_ubimtd_off) + 1 + sizeof(str_rootwait) + sizeof(str_rootfstype) + strlen(item->fstype) + 2 + sizeof(str_mtdparts) + strlenn(params->cfg->mtdparts) + sizeof(str_fbcon) + strlenn(params->cfg->fbcon) + sizeof(char) + strlenn(item->cmdline); cmdline_arg = (char *)malloc(n); if (NULL == cmdline_arg) { perror("Can't allocate memory for cmdline_arg"); } else { strcpy(cmdline_arg, str_cmdline_start); /* --command-line=root= */ if (item->fstype) { /* default fstype to mount */ strcpy(mount_fstype, item->fstype); /* extra tags when we detect UBI */ if (!strncmp(item->fstype,"ubi",3)) { /* mtd id [0-15] - one or two digits */ if(isdigit(atoi(item->device+strlen(item->device)-2))) { strcpy(str_mtd_id, item->device+strlen(item->device)-2); strcat(str_mtd_id, item->device+strlen(item->device)-1); } else { strcpy(str_mtd_id, item->device+strlen(item->device)-1); } /* get corresponding ubi dev to mount */ u = find_attached_ubi_device(str_mtd_id); sprintf(mount_dev, "/dev/ubi%d", u); /* FIXME: first volume is hardcoded */ strcat(mount_dev, "_0"); /* HARDCODED: we assume it's ubifs */ strcpy(mount_fstype,"ubifs"); /* extra cmdline tags when we detect ubi */ strcat(cmdline_arg, str_ubirootdev); /* FIXME: first volume is hardcoded */ strcat(cmdline_arg, "_0"); strcat(cmdline_arg, str_ubimtd); strcat(cmdline_arg, str_mtd_id); #ifdef UBI_VID_HDR_OFFSET strcat(cmdline_arg, ","); strcat(cmdline_arg, str_ubimtd_off); #endif } else { strcat(cmdline_arg, item->device); /* root=item->device */ } strcat(cmdline_arg, str_rootfstype); strcat(cmdline_arg, mount_fstype); } strcat(cmdline_arg, str_rootwait); if (params->cfg->mtdparts) { strcat(cmdline_arg, str_mtdparts); strcat(cmdline_arg, params->cfg->mtdparts); } if (params->cfg->fbcon) { strcat(cmdline_arg, str_fbcon); strcat(cmdline_arg, params->cfg->fbcon); } if (item->cmdline) { strcat(cmdline_arg, " "); strcat(cmdline_arg, item->cmdline); } load_argv[idx] = cmdline_arg; ++idx; } } /* fill '--initrd' option */ if (item->initrd) { /* allocate space */ n = sizeof(str_initrd_start) + strlen(item->initrd); initrd_arg = (char *)malloc(n); if (NULL == initrd_arg) { perror("Can't allocate memory for initrd_arg"); } else { strcpy(initrd_arg, str_initrd_start); /* --initrd= */ strcat(initrd_arg, item->initrd); load_argv[idx] = initrd_arg; ++idx; } } /* Append kernelpath as last arg of kexec */ load_argv[idx] = item->kernelpath; DPRINTF("load_argv: %s, %s, %s, %s, %s", load_argv[0], load_argv[1], load_argv[2], load_argv[3], load_argv[4]); /* Mount boot device */ if ( -1 == mount(mount_dev, mount_point, mount_fstype, MS_RDONLY, NULL) ) { perror("Can't mount boot device"); exit(-1); } /* Load kernel */ n = fexecw(kexec_path, (char *const *)load_argv, envp); if (-1 == n) { perror("Kexec can't load kernel"); exit(-1); } umount(mount_point); dispose(cmdline_arg); dispose(initrd_arg); /* Check /proc/sys/net presence */ if ( -1 == stat("/proc/sys/net", &sinfo) ) { if (ENOENT == errno) { /* We have no network, don't issue ifdown() while kexec'ing */ exec_argv[2] = "-x"; DPRINTF("No network is detected, disabling ifdown()"); } else { perror("Can't stat /proc/sys/net"); } } DPRINTF("exec_argv: %s, %s, %s", exec_argv[0], exec_argv[1], exec_argv[2]); /* Boot new kernel */ execve(kexec_path, (char *const *)exec_argv, envp); }
int scan_devices(struct params_t *params) { struct charlist *fl; struct bootconf_t *bootconf; struct device_t dev; struct cfgdata_t cfgdata; int rc,n; FILE *f; char mount_dev[16]; char mount_fstype[16]; char str_mtd_id[3]; #ifdef USE_ICONS kx_cfg_section *sc; int i; int rows; char **xpm_data; #endif bootconf = create_bootcfg(4); if (NULL == bootconf) { DPRINTF("Can't allocate bootconf structure"); return -1; } f = devscan_open(&fl); if (NULL == f) { log_msg(lg, "Can't initiate device scan"); return -1; } #ifdef USE_ZAURUS struct zaurus_partinfo_t pinfo; int zaurus_error = 0; zaurus_error = zaurus_read_partinfo(&pinfo); if (0 == zaurus_error) { /* Fix mtdparts tag */ dispose(params->cfg->mtdparts); params->cfg->mtdparts = zaurus_mtdparts(&pinfo); } #endif for (;;) { rc = devscan_next(f, fl, &dev); if (rc < 0) continue; /* Error */ if (0 == rc) break; /* EOF */ /* initialize with defaults */ strcpy(mount_dev, dev.device); strcpy(mount_fstype, dev.fstype); /* We found an ubi erase counter */ if (!strncmp(dev.fstype, "ubi",3)) { /* attach ubi boot device - mtd id [0-15] */ if(isdigit(atoi(dev.device+strlen(dev.device)-2))) { strcpy(str_mtd_id, dev.device+strlen(dev.device)-2); strcat(str_mtd_id, dev.device+strlen(dev.device)-1); } else { strcpy(str_mtd_id, dev.device+strlen(dev.device)-1); } n = ubi_attach(str_mtd_id); /* we have attached ubiX and we mount /dev/ubiX_0 */ sprintf(mount_dev, "/dev/ubi%d", n); /* HARDCODED: first volume */ strcat(mount_dev, "_0"); /* HARDCODED: we assume it's ubifs */ strcpy(mount_fstype, "ubifs"); } /* Mount device */ if (-1 == mount(mount_dev, MOUNTPOINT, mount_fstype, MS_RDONLY, NULL)) { log_msg(lg, "+ can't mount device %s: %s", mount_dev, ERRMSG); goto free_device; } /* NOTE: Don't go out before umount'ing */ /* Search boot method and return boot info */ rc = get_bootinfo(&cfgdata); if (-1 == rc) { /* Error */ goto umount; } #ifdef USE_ICONS /* Iterate over sections found */ if (params->gui) { for (i = 0; i < cfgdata.count; i++) { sc = cfgdata.list[i]; if (!sc) continue; /* Load custom icon */ if (sc->iconpath) { rows = xpm_load_image(&xpm_data, sc->iconpath); if (-1 == rows) { log_msg(lg, "+ can't load xpm icon %s", sc->iconpath); continue; } sc->icondata = xpm_parse_image(xpm_data, rows); if (!sc->icondata) { log_msg(lg, "+ can't parse xpm icon %s", sc->iconpath); continue; } xpm_destroy_image(xpm_data, rows); } } } #endif umount: /* Umount device */ if (-1 == umount(MOUNTPOINT)) { log_msg(lg, "+ can't umount device: %s", ERRMSG); goto free_cfgdata; } if (-1 == rc) { /* Error */ goto free_cfgdata; } #ifdef USE_ZAURUS /* Fix partition sizes. We can have kernel in root and home partitions on NAND */ /* HACK: mtdblock devices are hardcoded */ if (0 == zaurus_error) { if (0 == strcmp(dev.device, "/dev/mtdblock2")) { /* root */ log_msg(lg, "+ [zaurus root] size of %s will be changed from %llu to %lu", dev.device, dev.blocks, pinfo.root); dev.blocks = pinfo.root; } else if (0 == strcmp(dev.device, "/dev/mtdblock3")) { /* home */ log_msg(lg, "+ [zaurus home] size of %s will be changed from %llu to %lu", dev.device, dev.blocks, pinfo.home); dev.blocks = pinfo.home; } } #endif /* Now we have something in cfgdata */ rc = addto_bootcfg(bootconf, &dev, &cfgdata); free_cfgdata: destroy_cfgdata(&cfgdata); free_device: free(dev.device); } free_charlist(fl); params->bootcfg = bootconf; return 0; }
int is_install_media(char *name) { char pathbuf[PATH_MAX] = {0}; char devinfo[PATH_MAX] = {0}; int fd; char *minor_s; dev_t dev; int ret = 0; struct stat statbuf; char *src; const char *fst; dbg("------> examining %s\n", name); /* Read the "dev" node in the sysfs dir which has major:minor * and create a temp device node to work with */ snprintf(pathbuf, sizeof(pathbuf), "%s/dev", name); fd = open(pathbuf, O_RDONLY); if (fd < 0) { dbg_perror("open"); return 0; } if ((ret = read(fd, devinfo, sizeof(devinfo)-1)) <= 0) { dbg_perror("read"); return 0; } close(fd); devinfo[ret] = '\0'; ret = 0; minor_s = strchr(devinfo, ':'); if (!minor_s) return 0; *minor_s = '\0'; minor_s++; dev = makedev(atoi(devinfo), atoi(minor_s)); if (mknod(TMP_NODE, S_IFBLK, dev)) { dbg_perror("mknod"); return 0; } fst = detect_fs(TMP_NODE); if (!fst) { dbg("Not the right fs type\n"); goto out_unlink; } strcpy(pathbuf, INSTALL_MOUNT); if ((src = getenv("SRC"))) { strcat(pathbuf, src); } else if ((src = getenv("BOOT_IMAGE"))) { strcat(pathbuf, src); if ((src = strrchr(pathbuf, '/'))) *src = '\0'; } dbg("Mounting device %d:%d type=%s\n", major(dev), minor(dev), fst); /* Try to mount the fs */ if (mount(TMP_NODE, INSTALL_MOUNT, fst, MS_RDONLY, "")) { dbg_perror("mount"); goto out_unlink; } if (mount(pathbuf, INSTALL_MEDIA, "", MS_BIND, NULL)) { dbg_perror("mount_bind"); umount(INSTALL_MOUNT); goto out_unlink; } /* It mounted - check for cookie */ if (stat(INSTALL_MEDIA "/iago-cookie", &statbuf)) { dbg_perror("stat iago cookie"); umount(INSTALL_MEDIA); umount(INSTALL_MOUNT); } else { dbg("'%s %s' is Iago media\n", name, pathbuf); ret = 1; } out_unlink: unlink(TMP_NODE); return ret; }
int main( int argc, char **argv ) { int err; CYG_TEST_INIT(); // -------------------------------------------------------------- createfile( "/foo", 202 ); checkfile( "foo" ); copyfile( "foo", "fee"); checkfile( "fee" ); comparefiles( "foo", "/fee" ); err = mkdir( "/bar", 0 ); if( err < 0 ) SHOW_RESULT( mkdir, err ); listdir( "/" , false); copyfile( "fee", "/bar/fum" ); checkfile( "bar/fum" ); comparefiles( "/fee", "bar/fum" ); err = chdir( "bar" ); if( err < 0 ) SHOW_RESULT( chdir, err ); err = rename( "/foo", "bundy" ); if( err < 0 ) SHOW_RESULT( rename, err ); listdir( "/", true ); listdir( "" , true ); checkfile( "/bar/bundy" ); comparefiles("/fee", "bundy" ); testfs_dump(); // -------------------------------------------------------------- err = unlink( "/fee" ); if( err < 0 ) SHOW_RESULT( unlink, err ); err = unlink( "fum" ); if( err < 0 ) SHOW_RESULT( unlink, err ); err = unlink( "/bar/bundy" ); if( err < 0 ) SHOW_RESULT( unlink, err ); err = chdir( "/" ); if( err < 0 ) SHOW_RESULT( chdir, err ); err = rmdir( "/bar" ); if( err < 0 ) SHOW_RESULT( rmdir, err ); listdir( "/", false ); // -------------------------------------------------------------- err = mount( "", "/ram", "testfs" ); if( err < 0 ) SHOW_RESULT( mount, err ); createfile( "/ram/tinky", 456 ); copyfile( "/ram/tinky", "/ram/laalaa" ); checkfile( "/ram/tinky"); checkfile( "/ram/laalaa"); comparefiles( "/ram/tinky", "/ram/laalaa" ); err = chdir( "/ram" ); if( err < 0 ) SHOW_RESULT( chdir, err ); createfile( "tinky", 678 ); checkfile( "tinky" ); maxfile( "dipsy" ); checkfile( "dipsy" ); copyfile( "dipsy", "po" ); checkfile( "po" ); comparefiles( "dipsy", "po" ); testfs_dump(); // -------------------------------------------------------------- err = unlink( "tinky" ); if( err < 0 ) SHOW_RESULT( unlink, err ); err = unlink( "dipsy" ); if( err < 0 ) SHOW_RESULT( unlink, err ); err = unlink( "po" ); if( err < 0 ) SHOW_RESULT( unlink, err ); err = unlink( "laalaa" ); if( err < 0 ) SHOW_RESULT( unlink, err ); err = chdir( "/" ); if( err < 0 ) SHOW_RESULT( chdir, err ); err = umount( "/ram" ); if( err < 0 ) SHOW_RESULT( umount, err ); CYG_TEST_PASS_FINISH("fileio1"); }
int main(int ac, char **av) { int lc, i; char *msg; if ((msg = parse_opts(ac, av, options, &help)) != NULL) tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); /* Check for mandatory option of the testcase */ if (!Dflag) { tst_brkm(TBROK, NULL, "you must specify the device used for mounting with -D " "option"); } if (Tflag) { Fstype = (char *)malloc(strlen(fstype)+1); if (Fstype == NULL) { tst_brkm(TBROK|TERRNO, NULL, "malloc failed"); } Fstype[strlen(fstype)] = '\0'; strncpy(Fstype, fstype, strlen(fstype)); } else { Fstype = (char *)malloc(strlen(DEFAULT_FSTYPE)+1); if (Fstype == NULL) { tst_brkm(TBROK|TERRNO, NULL, "malloc failed"); } strncpy(Fstype, DEFAULT_FSTYPE, strlen(DEFAULT_FSTYPE)); Fstype[strlen(DEFAULT_FSTYPE)] = '\0'; } if (STD_COPIES != 1) { tst_resm(TINFO, "-c option has no effect for this testcase - " "%s doesn't allow running more than one instance " "at a time", TCID); STD_COPIES = 1; } setup(); for (lc = 0; TEST_LOOPING(lc); lc++) { Tst_count = 0; for (i = 0; i < TST_TOTAL; ++i) { /* Call mount(2) */ TEST(mount(device, mntpoint, Fstype, rwflags[i], NULL)); /* check return code */ if (TEST_RETURN != 0) { tst_resm(TFAIL|TTERRNO, "mount(2) failed"); continue; } /* Validate the rwflag */ if (test_rwflag(i, lc) == 1) { tst_resm(TFAIL, "mount(2) failed while" " validating %ld", rwflags[i]); } else { tst_resm(TPASS, "mount(2) passed with " "rwflag = %ld", rwflags[i]); } TEST(umount(mntpoint)); if (TEST_RETURN != 0) { tst_brkm(TBROK|TTERRNO, cleanup, "umount(2) failed for %s", mntpoint); } } } /* cleanup and exit */ cleanup(); tst_exit(); }
int main(int argc, char **argv) { int fd; #if defined(USE_FUSE) struct fuse_args margs = FUSE_ARGS_INIT(0, NULL); #endif conf.born = time(NULL); umask(0); atexit(goodbye); signal_init(); evt_init(); blockheap_init(); dconf_init("fs-pkg.cf"); dlink_init(); pkg_init(); inode_init(); if (dconf_get_bool("sys.daemonize", 0) == 1) { fprintf(stdout, "going bg, bye!\n"); /* * XXX: add daemon crud */ } /* * open log file, if its valid, otherwise assume debug mode and use stdout */ if ((conf.log_fp = log_open(dconf_get_str("path.log", NULL))) == NULL) conf.log_fp = stdout; Log(LOG_INFO, "%s %s starting up...", argv[0], VERSION); if (!conf.mountpoint) conf.mountpoint = dconf_get_str("path.mountpoint", "/test"); #if defined(USE_FUSE) /* * only way to make gcc happy...argh;) -bk */ vfs_fuse_args = margs; /* * The fuse_mount() options get modified, so we always rebuild it */ if ((fuse_opt_add_arg(&vfs_fuse_args, argv[0]) == -1 || fuse_opt_add_arg(&vfs_fuse_args, "-o") == -1 || fuse_opt_add_arg(&vfs_fuse_args, "nonempty,allow_other") == -1)) Log(LOG_ERROR, "Failed to set FUSE options.\n"); umount(conf.mountpoint); vfs_fuse_init(); #endif Log(LOG_DEBUG, "Opening database %s", dconf_get_str("path.db", ":memory")); db_sqlite_open(dconf_get_str("path.db", ":memory")); /* * set up the watch subsystem */ vfs_watch_init(); /* * walk the package dirs and import all existing packages */ vfs_dir_walk(); /* * the big event loop */ while (!conf.dying) { ev_loop(evt_loop, 0); } /* * shouldnt be reached... */ return EXIT_SUCCESS; }
int main(int argc, char **argv) { char *varstr; int rc; int varStatus; char *szSessionInfo = "dm_test session info"; dm_eventset_t events; DMOPT_PARSE(argc, argv); DMLOG_START(); DMEV_ZERO(events); DMEV_SET(DM_EVENT_MOUNT, events); /* CANNOT DO ANYTHING WITHOUT SUCCESSFUL INITIALIZATION!!! */ if ((rc = dm_init_service(&varstr)) != 0) { DMLOG_PRINT(DMLVL_ERR, "dm_init_service failed! (rc = %d, errno = %d)\n", rc, errno); DM_EXIT(); } else if ((rc = dm_create_session(DM_NO_SESSION, szSessionInfo, &sid)) == -1) { DMLOG_PRINT(DMLVL_ERR, "dm_create_session failed! (rc = %d, errno = %d)\n", rc, errno); DM_EXIT(); } else if ((rc = dm_set_disp(sid, DM_GLOBAL_HANP, DM_GLOBAL_HLEN, DM_NO_TOKEN, &events, DM_EVENT_MAX)) == -1) { DMLOG_PRINT(DMLVL_ERR, "dm_set_disp failed! (rc = %d, errno = %d)\n", rc, errno); dm_destroy_session(sid); DM_EXIT(); } else if ((rc = pthread_create(&tid, NULL, Thread, NULL)) != 0) { DMLOG_PRINT(DMLVL_ERR, "pthread_create failed! (rc = %d, errno = %d)\n", rc, errno); dm_destroy_session(sid); DM_EXIT(); } else if ((rc = dmimpl_mount(&mountPt, &deviceNm)) == -1) { DMLOG_PRINT(DMLVL_ERR, "dmimpl_mount failed! (rc = %d, errno = %d)\n", rc, errno); dm_destroy_session(sid); DM_EXIT(); } else { sprintf(DummyFile, "%s/%s", mountPt, DUMMY_FILE); sprintf(DummyFile2, "%s/%s", mountPt, DUMMY_FILE2); sprintf(DummySubdir, "%s/%s", mountPt, DUMMY_SUBDIR); sprintf(DummySubdir2, "%s/%s", mountPt, DUMMY_SUBDIR2); sprintf(DummyLink, "%s/%s", mountPt, DUMMY_LINK); remove(DummyFile); remove(DummyFile2); unlink(DummyLink); rmdir(DummySubdir); rmdir(DummySubdir2); } DMLOG_PRINT(DMLVL_DEBUG, "Starting DMAPI synchronous namespace event tests\n") ; /* * TEST : mkdir - DM_RESP_CONTINUE * EXPECTED: DM_EVENT_CREATE */ if (DMVAR_EXEC(DIR_SYNC_NAMESP_EVENT_BASE + 1)) { dm_ino_t ino; /* Variation set up */ eventExpected = DM_EVENT_CREATE; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; /* Variation */ EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "mkdir(%s)\n", DummySubdir); rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE); DMLOG_PRINT(DMLVL_DEBUG, "mkdir(%s) returned %d\n", DummySubdir, rc); if ((varStatus = DMVAR_CHKPASSEXP(0, rc, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_SUBDIR) != 0) { DMLOG_PRINT(DMLVL_ERR, "Entry name NOT correct! (%s vs %s)\n", name1, DUMMY_SUBDIR); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ EVENT_DELIVERY_DELAY; rc = rmdir(DummySubdir); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } } /* * TEST : mkdir - DM_RESP_ABORT * EXPECTED: DM_EVENT_CREATE */ if (DMVAR_EXEC(DIR_SYNC_NAMESP_EVENT_BASE + 2)) { dm_ino_t ino; /* Variation set up */ eventExpected = DM_EVENT_CREATE; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_ABORT; /* Variation */ EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "mkdir(%s)\n", DummySubdir); rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE); DMLOG_PRINT(DMLVL_DEBUG, "mkdir(%s) returned %d\n", DummySubdir, rc); if ((varStatus = DMVAR_CHKFAILEXP(-1, rc, ABORT_ERRNO, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_SUBDIR) != 0) { DMLOG_PRINT(DMLVL_ERR, "Entry name NOT correct! (%s vs %s)\n", name1, DUMMY_SUBDIR); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ } /* * TEST : rmdir - DM_RESP_CONTINUE * EXPECTED: DM_EVENT_REMOVE */ if (DMVAR_EXEC(DIR_SYNC_NAMESP_EVENT_BASE + 3)) { dm_ino_t ino; /* Variation set up */ eventExpected = DM_EVENT_REMOVE; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "rmdir(%s)\n", DummySubdir); rc = rmdir(DummySubdir); DMLOG_PRINT(DMLVL_DEBUG, "rmdir(%s) returned %d\n", DummySubdir, rc); if ((varStatus = DMVAR_CHKPASSEXP(0, rc, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_SUBDIR) != 0) { DMLOG_PRINT(DMLVL_ERR, "Entry name NOT correct! (%s vs %s)\n", name1, DUMMY_SUBDIR); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ } } /* * TEST : rmdir - DM_RESP_ABORT * EXPECTED: DM_EVENT_REMOVE */ if (DMVAR_EXEC(DIR_SYNC_NAMESP_EVENT_BASE + 4)) { dm_ino_t ino; /* Variation set up */ eventExpected = DM_EVENT_REMOVE; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ eventResponse = DM_RESP_ABORT; EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "rmdir(%s)\n", DummySubdir); rc = rmdir(DummySubdir); DMLOG_PRINT(DMLVL_DEBUG, "rmdir(%s) returned %d\n", DummySubdir, rc); if ((varStatus = DMVAR_CHKFAILEXP(-1, rc, ABORT_ERRNO, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_SUBDIR) != 0) { DMLOG_PRINT(DMLVL_ERR, "Entry name NOT correct! (%s vs %s)\n", name1, DUMMY_SUBDIR); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; rc = rmdir(DummySubdir); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } } } /* * TEST : mv - DM_RESP_CONTINUE * EXPECTED: DM_EVENT_RENAME */ if (DMVAR_EXEC(DIR_SYNC_NAMESP_EVENT_BASE + 5)) { dm_ino_t ino1, ino2; /* Variation set up */ eventExpected = DM_EVENT_RENAME; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; sprintf(command, "mv %s %s", DummySubdir, DummySubdir2); EVENT_DELIVERY_DELAY; rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "system(mv %s %s)\n", DummySubdir, DummySubdir2); rc = system(command); DMLOG_PRINT(DMLVL_DEBUG, "system(mv %s %s) returned %d\n", DummySubdir, DummySubdir2, rc); if ((varStatus = DMVAR_CHKPASSEXP(0, rc, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino1); rc |= dm_handle_to_ino(hanp2, hlen2, &ino2); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino1 != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Old parent handle NOT root! (%lld vs %d)\n", ino1, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (ino2 != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "New parent handle NOT root! (%lld vs %d)\n", ino2, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (dm_handle_cmp(hanp1, hlen1, hanp2, hlen2) != 0) { DMLOG_PRINT(DMLVL_ERR, "Old parent handle NOT equal to new parent handle!\n"); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_SUBDIR) != 0) { DMLOG_PRINT(DMLVL_ERR, "Old entry name NOT correct! (%s vs %s)\n", name1, DUMMY_SUBDIR); varStatus = DMSTAT_FAIL; } else if (strcmp(name2, DUMMY_SUBDIR2) != 0) { DMLOG_PRINT(DMLVL_ERR, "New entry name NOT correct! (%s vs %s)\n", name2, DUMMY_SUBDIR2); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ EVENT_DELIVERY_DELAY; rc = rmdir(DummySubdir2); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } } } /* * TEST : mv - DM_RESP_ABORT * EXPECTED: DM_EVENT_RENAME */ if (DMVAR_EXEC(DIR_SYNC_NAMESP_EVENT_BASE + 6)) { dm_ino_t ino1, ino2; /* Variation set up */ eventExpected = DM_EVENT_RENAME; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; sprintf(command, "mv %s %s", DummySubdir, DummySubdir2); EVENT_DELIVERY_DELAY; rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ eventResponse = DM_RESP_ABORT; EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "system(mv %s %s)\n", DummySubdir, DummySubdir2); rc = system(command); DMLOG_PRINT(DMLVL_DEBUG, "system(mv %s %s) returned %d\n", DummySubdir, DummySubdir2, rc); if ((varStatus = (rc == 0 ? DMSTAT_FAIL : DMSTAT_PASS)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino1); rc |= dm_handle_to_ino(hanp2, hlen2, &ino2); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino1 != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Old parent handle NOT root! (%lld vs %d)\n", ino1, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (ino2 != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "New parent handle NOT root! (%lld vs %d)\n", ino2, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (dm_handle_cmp(hanp1, hlen1, hanp2, hlen2) != 0) { DMLOG_PRINT(DMLVL_ERR, "Old parent handle NOT equal to new parent handle!\n"); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_SUBDIR) != 0) { DMLOG_PRINT(DMLVL_ERR, "Old entry name NOT correct! (%s vs %s)\n", name1, DUMMY_SUBDIR); varStatus = DMSTAT_FAIL; } else if (strcmp(name2, DUMMY_SUBDIR2) != 0) { DMLOG_PRINT(DMLVL_ERR, "New entry name NOT correct! (%s vs %s)\n", name2, DUMMY_SUBDIR2); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; rc = rmdir(DummySubdir); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } } } /* * TEST : symlink - DM_RESP_CONTINUE * EXPECTED: DM_EVENT_SYMLINK */ if (DMVAR_EXEC(DIR_SYNC_NAMESP_EVENT_BASE + 7)) { dm_ino_t ino; /* Variation set up */ eventExpected = DM_EVENT_SYMLINK; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "symlink(%s, %s)\n", DummySubdir, DummySubdir2); rc = symlink(DummySubdir, DummySubdir2); DMLOG_PRINT(DMLVL_DEBUG, "symlink(%s, %s) returned %d\n", DummySubdir, DummySubdir2, rc); if ((varStatus = DMVAR_CHKPASSEXP(0, rc, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_SUBDIR2) != 0) { DMLOG_PRINT(DMLVL_ERR, "Symlink entry name NOT correct! (%s vs %s)\n", name1, DUMMY_SUBDIR2); varStatus = DMSTAT_FAIL; } else if (strcmp(name2, DummySubdir) != 0) { DMLOG_PRINT(DMLVL_ERR, "Symlink contents NOT correct! (%s vs %s)\n", name2, DummySubdir); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ EVENT_DELIVERY_DELAY; rc = unlink(DummySubdir2); rc |= rmdir(DummySubdir); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } } } /* * TEST : symlink - DM_RESP_ABORT * EXPECTED: DM_EVENT_SYMLINK */ if (DMVAR_EXEC(DIR_SYNC_NAMESP_EVENT_BASE + 8)) { dm_ino_t ino; /* Variation set up */ eventExpected = DM_EVENT_SYMLINK; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ eventResponse = DM_RESP_ABORT; EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "symlink(%s, %s)\n", DummySubdir, DummySubdir2); rc = symlink(DummySubdir, DummySubdir2); DMLOG_PRINT(DMLVL_DEBUG, "symlink(%s, %s) returned %d\n", DummySubdir, DummySubdir2, rc); EVENT_DELIVERY_DELAY; if ((varStatus = DMVAR_CHKFAILEXP(-1, rc, ABORT_ERRNO, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_SUBDIR2) != 0) { DMLOG_PRINT(DMLVL_ERR, "Symlink entry name NOT correct! (%s vs %s)\n", name1, DUMMY_SUBDIR2); varStatus = DMSTAT_FAIL; } else if (strcmp(name2, DummySubdir) != 0) { DMLOG_PRINT(DMLVL_ERR, "Symlink contents NOT correct! (%s vs %s)\n", name2, DummySubdir); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; rc = rmdir(DummySubdir); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } } } /* * TEST : link - DM_RESP_CONTINUE * EXPECTED: DM_EVENT_LINK */ if (DMVAR_EXEC(DIR_SYNC_NAMESP_EVENT_BASE + 9)) { #ifdef DIRECTORY_LINKS dm_ino_t ino1, ino2, ino3; void *hanp; size_t hlen; /* Variation set up */ eventExpected = DM_EVENT_LINK; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; if ((rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE)) == -1) { /* No clean up */ } else if ((rc = dm_path_to_handle(DummySubdir, &hanp, &hlen)) == -1) { rmdir(DummySubdir); } if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "link(%s, %s)\n", DummySubdir, DummyLink); rc = link(DummySubdir, DummyLink); DMLOG_PRINT(DMLVL_DEBUG, "link(%s, %s) returned %d\n", DummySubdir, DummyLink, rc); if ((varStatus = DMVAR_CHKPASSEXP(0, rc, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino1); rc |= dm_handle_to_ino(hanp2, hlen2, &ino2); rc |= dm_handle_to_ino(hanp, hlen, &ino3); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino1 != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino1, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (ino2 != ino3) { DMLOG_PRINT(DMLVL_ERR, "Source link handle NOT correct! (%lld vs %lld)\n", ino2, ino3); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_LINK) != 0) { DMLOG_PRINT(DMLVL_ERR, "Target entry name NOT correct! (%s vs %s)\n", name1, DUMMY_LINK); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ EVENT_DELIVERY_DELAY; rc = rmdir(DummySubdir); rc |= unlink(DummyLink); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } dm_handle_free(hanp, hlen); } #else DMLOG_PRINT(DMLVL_WARN, "Test case not built with DIRECTORY_LINKS defined\n"); DMVAR_SKIP(); #endif } /* * TEST : link - DM_RESP_ABORT * EXPECTED: DM_EVENT_LINK */ if (DMVAR_EXEC(DIR_SYNC_NAMESP_EVENT_BASE + 10)) { #ifdef DIRECTORY_LINKS dm_ino_t ino1, ino2, ino3; void *hanp; size_t hlen; /* Variation set up */ eventExpected = DM_EVENT_LINK; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; if ((rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE)) == -1) { /* No clean up */ } else if ((rc = dm_path_to_handle(DummySubdir, &hanp, &hlen)) == -1) { rmdir(DummySubdir); } if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ eventResponse = DM_RESP_ABORT; EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "link(%s, %s)\n", DummySubdir, DummyLink); rc = link(DummySubdir, DummyLink); DMLOG_PRINT(DMLVL_DEBUG, "link(%s, %s) returned %d\n", DummySubdir, DummyLink, rc); if ((varStatus = DMVAR_CHKFAILEXP(-1, rc, ABORT_ERRNO, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino1); rc |= dm_handle_to_ino(hanp2, hlen2, &ino2); rc |= dm_handle_to_ino(hanp, hlen, &ino3); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino1 != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino1, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (ino2 != ino3) { DMLOG_PRINT(DMLVL_ERR, "Source link handle NOT correct! (%lld vs %lld)\n", ino2, ino3); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_LINK) != 0) { DMLOG_PRINT(DMLVL_ERR, "Target entry name NOT correct! (%s vs %s)\n", name1, DUMMY_LINK); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; rc = rmdir(DummySubdir); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } dm_handle_free(hanp, hlen); } #else DMLOG_PRINT(DMLVL_WARN, "Test case not built with DIRECTORY_LINKS defined\n"); DMVAR_SKIP(); #endif } /* * TEST : open * EXPECTED: DM_EVENT_CREATE, DM_RESP_CONTINUE */ if (DMVAR_EXEC(FILE_SYNC_NAMESP_EVENT_BASE + 1)) { int fd; dm_ino_t ino; /* Variation set up */ eventExpected = DM_EVENT_CREATE; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; /* Variation */ EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "open(%s)\n", DummyFile); fd = open(DummyFile, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE); DMLOG_PRINT(DMLVL_DEBUG, "open(%s) returned %d\n", DummyFile, fd); rc = (fd == -1) ? -1 : 0; if ((varStatus = DMVAR_CHKPASSEXP(0, rc, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_FILE) != 0) { DMLOG_PRINT(DMLVL_ERR, "Entry name NOT correct! (%s %s)\n", name1, DUMMY_SUBDIR); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ EVENT_DELIVERY_DELAY; rc = close(fd); rc |= remove(DummyFile); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } } /* * TEST : open * EXPECTED: DM_EVENT_CREATE, DM_RESP_ABORT */ if (DMVAR_EXEC(FILE_SYNC_NAMESP_EVENT_BASE + 2)) { dm_ino_t ino; int fd; /* Variation set up */ eventExpected = DM_EVENT_CREATE; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_ABORT; /* Variation */ EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "open(%s)\n", DummyFile); fd = open(DummyFile, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE); DMLOG_PRINT(DMLVL_DEBUG, "open(%s) returned %d\n", DummyFile, fd); if ((varStatus = DMVAR_CHKFAILEXP(-1, fd, ABORT_ERRNO, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_FILE) != 0) { DMLOG_PRINT(DMLVL_ERR, "Entry name NOT correct! (%s vs %s)\n", name1, DUMMY_FILE); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ } /* * TEST : remove * EXPECTED: DM_EVENT_REMOVE, DM_RESP_CONTINUE */ if (DMVAR_EXEC(FILE_SYNC_NAMESP_EVENT_BASE + 3)) { dm_ino_t ino; int fd; /* Variation set up */ eventExpected = DM_EVENT_REMOVE; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; if ((fd = open(DummyFile, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE)) != -1) { rc = close(fd); } if (fd == -1 || rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "remove(%s)\n", DummyFile); rc = remove(DummyFile); DMLOG_PRINT(DMLVL_DEBUG, "remove(%s) returned %d\n", DummyFile, rc); if ((varStatus = DMVAR_CHKPASSEXP(0, rc, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_FILE) != 0) { DMLOG_PRINT(DMLVL_ERR, "Entry name NOT correct! (%s vs %s)\n", name1, DUMMY_FILE); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ } } /* * TEST : remove * EXPECTED: DM_EVENT_REMOVE, DM_RESP_ABORT */ if (DMVAR_EXEC(FILE_SYNC_NAMESP_EVENT_BASE + 4)) { dm_ino_t ino; int fd; /* Variation set up */ eventExpected = DM_EVENT_REMOVE; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; if ((fd = open(DummyFile, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE)) != -1) { rc = close(fd); } if (fd == -1 || rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ eventResponse = DM_RESP_ABORT; EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "remove(%s)\n", DummyFile); rc = remove(DummyFile); DMLOG_PRINT(DMLVL_DEBUG, "remove(%s) returned %d\n", DummyFile, rc); if ((varStatus = DMVAR_CHKFAILEXP(-1, rc, ABORT_ERRNO, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_FILE) != 0) { DMLOG_PRINT(DMLVL_ERR, "Entry name NOT correct! (%s vs %s)\n", name1, DUMMY_FILE); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; rc = remove(DummyFile); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } } } /* * TEST : mv * EXPECTED: DM_EVENT_RENAME, DM_RESP_CONTINUE */ if (DMVAR_EXEC(FILE_SYNC_NAMESP_EVENT_BASE + 5)) { dm_ino_t ino1, ino2; int fd; /* Variation set up */ eventExpected = DM_EVENT_RENAME; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; sprintf(command, "mv %s %s", DummyFile, DummyFile2); EVENT_DELIVERY_DELAY; if ((fd = open(DummyFile, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE)) != -1) { rc = close(fd); } if (fd == -1 || rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "system(mv %s %s)\n", DummyFile, DummyFile2); rc = system(command); DMLOG_PRINT(DMLVL_DEBUG, "system(mv %s %s) returned %d\n", DummyFile, DummyFile2, rc); if ((varStatus = DMVAR_CHKPASSEXP(0, rc, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino1); rc |= dm_handle_to_ino(hanp2, hlen2, &ino2); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino1 != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Old parent handle NOT root! (%lld vs %d)\n", ino1, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (ino2 != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "New parent handle NOT root! (%lld vs %d)\n", ino2, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (dm_handle_cmp(hanp1, hlen1, hanp2, hlen2) != 0) { DMLOG_PRINT(DMLVL_ERR, "Old parent handle NOT equal to new parent handle!\n"); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_FILE) != 0) { DMLOG_PRINT(DMLVL_ERR, "Old entry name NOT correct! (%s vs %s)\n", name1, DUMMY_FILE); varStatus = DMSTAT_FAIL; } else if (strcmp(name2, DUMMY_FILE2) != 0) { DMLOG_PRINT(DMLVL_ERR, "New entry name NOT correct! (%s vs %s)\n", name2, DUMMY_FILE2); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ EVENT_DELIVERY_DELAY; rc = remove(DummyFile2); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); } } } /* * TEST : mv * EXPECTED: DM_EVENT_RENAME, DM_RESP_ABORT */ if (DMVAR_EXEC(FILE_SYNC_NAMESP_EVENT_BASE + 6)) { dm_ino_t ino1, ino2; int fd; /* Variation set up */ eventExpected = DM_EVENT_RENAME; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; sprintf(command, "mv %s %s", DummyFile, DummyFile2); EVENT_DELIVERY_DELAY; if ((fd = open(DummyFile, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE)) != -1) { rc = close(fd); } if (fd == -1 || rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ eventResponse = DM_RESP_ABORT; EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "system(mv %s %s)\n", DummyFile, DummyFile2); rc = system(command); DMLOG_PRINT(DMLVL_DEBUG, "system(mv %s %s) returned %d\n", DummyFile, DummyFile2, rc); if ((varStatus = (rc == 0 ? DMSTAT_FAIL : DMSTAT_PASS)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino1); rc |= dm_handle_to_ino(hanp2, hlen2, &ino2); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino1 != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Old parent handle NOT root! (%lld vs %d)\n", ino1, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (ino2 != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "New parent handle NOT root! (%lld vs %d)\n", ino2, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (dm_handle_cmp(hanp1, hlen1, hanp2, hlen2) != 0) { DMLOG_PRINT(DMLVL_ERR, "Old parent handle NOT equal to new parent handle!\n"); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_FILE) != 0) { DMLOG_PRINT(DMLVL_ERR, "Old entry name NOT correct! (%s vs %s)\n", name1, DUMMY_FILE); varStatus = DMSTAT_FAIL; } else if (strcmp(name2, DUMMY_FILE2) != 0) { DMLOG_PRINT(DMLVL_ERR, "New entry name NOT correct! (%s vs %s)\n", name2, DUMMY_FILE2); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; rc = remove(DummyFile); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } } } /* * TEST : symlink * EXPECTED: DM_EVENT_SYMLINK, DM_RESP_CONTINUE */ if (DMVAR_EXEC(FILE_SYNC_NAMESP_EVENT_BASE + 7)) { dm_ino_t ino; int fd; /* Variation set up */ eventExpected = DM_EVENT_SYMLINK; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; if ((fd = open(DummyFile, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE)) != -1) { rc = close(fd); } if (fd == -1 || rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "symlink(%s, %s)\n", DummyFile, DummyLink); rc = symlink(DummyFile, DummyLink); DMLOG_PRINT(DMLVL_DEBUG, "symlink(%s, %s) returned %d\n", DummyFile, DummyLink, rc); if ((varStatus = DMVAR_CHKPASSEXP(0, rc, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_LINK) != 0) { DMLOG_PRINT(DMLVL_ERR, "Symlink entry name NOT correct! (%s vs %s)\n", name1, DUMMY_LINK); varStatus = DMSTAT_FAIL; } else if (strcmp(name2, DummyFile) != 0) { DMLOG_PRINT(DMLVL_ERR, "Symlink contents NOT correct! (%s vs %s)\n", name2, DummyFile); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ EVENT_DELIVERY_DELAY; rc = unlink(DummyLink); rc |= remove(DummyFile); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } } } /* * TEST : symlink * EXPECTED: DM_EVENT_SYMLINK, DM_RESP_ABORT */ if (DMVAR_EXEC(FILE_SYNC_NAMESP_EVENT_BASE + 8)) { dm_ino_t ino; int fd; /* Variation set up */ eventExpected = DM_EVENT_SYMLINK; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; if ((fd = open(DummyFile, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE)) != -1) { rc = close(fd); } if (fd == -1 || rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ eventResponse = DM_RESP_ABORT; EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "symlink(%s, %s)\n", DummyFile, DummyLink); rc = symlink(DummyFile, DummyLink); DMLOG_PRINT(DMLVL_DEBUG, "symlink(%s, %s) returned %d\n", DummyFile, DummyLink, rc); if ((varStatus = DMVAR_CHKFAILEXP(-1, rc, ABORT_ERRNO, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_LINK) != 0) { DMLOG_PRINT(DMLVL_ERR, "Symlink entry name NOT correct! (%s vs %s)\n", name1, DUMMY_LINK); varStatus = DMSTAT_FAIL; } else if (strcmp(name2, DummyFile) != 0) { DMLOG_PRINT(DMLVL_ERR, "Symlink contents NOT correct! (%s vs %s)\n", name2, DummyFile); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; rc = remove(DummyFile); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } } } /* * TEST : link * EXPECTED: DM_EVENT_LINK, DM_RESP_CONTINUE */ if (DMVAR_EXEC(FILE_SYNC_NAMESP_EVENT_BASE + 9)) { dm_ino_t ino1, ino2, ino3; void *hanp; size_t hlen; int fd; /* Variation set up */ eventExpected = DM_EVENT_LINK; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; if ((fd = open(DummyFile, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE)) == -1) { /* No clean up */ } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { close(fd); } if (fd == -1 || rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "link(%s, %s)\n", DummyFile, DummyLink); rc = link(DummyFile, DummyLink); DMLOG_PRINT(DMLVL_DEBUG, "link(%s, %s) returned %d\n", DummyFile, DummyLink, rc); if ((varStatus = DMVAR_CHKPASSEXP(0, rc, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino1); rc |= dm_handle_to_ino(hanp2, hlen2, &ino2); rc |= dm_handle_to_ino(hanp, hlen, &ino3); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino1 != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino1, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (ino2 != ino3) { DMLOG_PRINT(DMLVL_ERR, "Source link handle NOT correct! (%lld vs %lld)\n", ino2, ino3); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_LINK) != 0) { DMLOG_PRINT(DMLVL_ERR, "Target entry name NOT correct! (%s vs %s)\n", name1, DUMMY_LINK); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ EVENT_DELIVERY_DELAY; rc = close(fd); rc |= remove(DummyFile); rc |= remove(DummyLink); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } dm_handle_free(hanp, hlen); } } /* * TEST : link * EXPECTED: DM_EVENT_LINK, DM_RESP_ABORT */ if (DMVAR_EXEC(FILE_SYNC_NAMESP_EVENT_BASE + 10)) { dm_ino_t ino1, ino2, ino3; void *hanp; size_t hlen; int fd; /* Variation set up */ eventExpected = DM_EVENT_LINK; eventReceived = DM_EVENT_INVALID; eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; if ((fd = open(DummyFile, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE)) == -1) { /* No clean up */ } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { close(fd); } if (fd == -1 || rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to set up variation! (errno = %d)\n", errno); DMVAR_SKIP(); } else { /* Variation */ eventResponse = DM_RESP_ABORT; EVENT_DELIVERY_DELAY; DMLOG_PRINT(DMLVL_DEBUG, "link(%s, %s)\n", DummyFile, DummyLink); rc = link(DummyFile, DummyLink); DMLOG_PRINT(DMLVL_DEBUG, "link(%s, %s) returned %d\n", DummyFile, DummyLink, rc); if ((varStatus = DMVAR_CHKFAILEXP(-1, rc, ABORT_ERRNO, eventExpected, eventReceived)) == DMSTAT_PASS) { rc = dm_handle_to_ino(hanp1, hlen1, &ino1); rc |= dm_handle_to_ino(hanp2, hlen2, &ino2); rc |= dm_handle_to_ino(hanp, hlen, &ino3); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "Unable to obtain inode!\n"); varStatus = DMSTAT_FAIL; } else if (ino1 != ROOT_INODE) { DMLOG_PRINT(DMLVL_ERR, "Parent handle NOT root! (%lld vs %d)\n", ino1, ROOT_INODE); varStatus = DMSTAT_FAIL; } else if (ino2 != ino3) { DMLOG_PRINT(DMLVL_ERR, "Source link handle NOT correct! (%lld vs %lld)\n", ino2, ino3); varStatus = DMSTAT_FAIL; } else if (strcmp(name1, DUMMY_LINK) != 0) { DMLOG_PRINT(DMLVL_ERR, "Target entry name NOT correct! (%s vs %s)\n", name1, DUMMY_LINK); varStatus = DMSTAT_FAIL; } } DMVAR_END(varStatus); /* Variation clean up */ eventResponse = DM_RESP_CONTINUE; EVENT_DELIVERY_DELAY; rc = close(fd); rc |= remove(DummyFile); if (rc == -1) { DMLOG_PRINT(DMLVL_DEBUG, "Unable to clean up variation! (errno = %d)\n", errno); } dm_handle_free(hanp, hlen); } } rc = umount(mountPt); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "umount failed! (rc = %d, errno = %d)\n", rc, errno); } pthread_join(tid, NULL); rc = dm_destroy_session(sid); if (rc == -1) { DMLOG_PRINT(DMLVL_ERR, "dm_destroy_session failed! (rc = %d, errno = %d)\n", rc, errno); } DMLOG_STOP(); tst_exit(); }
char * mountNfsImage(struct installMethod * method, char * location, struct loaderData_s * loaderData) { char * host = NULL; char * directory = NULL; char * mountOpts = NULL; char * fullPath = NULL; char * url = NULL; enum { NFS_STAGE_NFS, NFS_STAGE_MOUNT, NFS_STAGE_DONE, NFS_STAGE_UPDATES } stage = NFS_STAGE_NFS; int rc; /* JKFIXME: ASSERT -- we have a network device setup when we get here */ while (stage != NFS_STAGE_DONE) { switch (stage) { case NFS_STAGE_NFS: logMessage(INFO, "going to do nfsGetSetup"); if (loaderData->method == METHOD_NFS && loaderData->stage2Data) { host = ((struct nfsInstallData *)loaderData->stage2Data)->host; directory = ((struct nfsInstallData *)loaderData->stage2Data)->directory; if (((struct nfsInstallData *) loaderData->stage2Data)->mountOpts == NULL) { mountOpts = strdup("ro"); } else { if (asprintf(&mountOpts, "ro,%s", ((struct nfsInstallData *) loaderData->stage2Data)->mountOpts) == -1) { logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__); abort(); } } logMessage(INFO, "host is %s, dir is %s, opts are '%s'", host, directory, mountOpts); if (!host || !directory) { logMessage(ERROR, "missing host or directory specification"); if (loaderData->inferredStage2) loaderData->invalidRepoParam = 1; loaderData->method = -1; break; } else { host = strdup(host); directory = strdup(directory); } } else { char *substr, *tmp; if (nfsGetSetup(&host, &directory) == LOADER_BACK) return NULL; /* If the user-provided URL points at a repo instead of a * stage2 image, fix that up now. */ substr = strstr(directory, ".img"); if (!substr || (substr && *(substr+4) != '\0')) { if (asprintf(&(loaderData->instRepo), "nfs:%s:%s", host, directory) == -1) { logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__); abort(); } if (asprintf(&tmp, "nfs:%s:%s/images/install.img", host, directory) == -1) { logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__); abort(); } setStage2LocFromCmdline(tmp, loaderData); free(host); free(directory); free(tmp); continue; } loaderData->invalidRepoParam = 1; } stage = NFS_STAGE_MOUNT; break; case NFS_STAGE_MOUNT: { char *buf; if (asprintf(&fullPath, "%s:%.*s", host, (int) (strrchr(directory, '/')-directory), directory) == -1) { logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__); abort(); } logMessage(INFO, "mounting nfs path %s", fullPath); if (FL_TESTING(flags)) { stage = NFS_STAGE_DONE; break; } stage = NFS_STAGE_NFS; if (!doPwMount(fullPath, "/mnt/stage2", "nfs", mountOpts, NULL)) { if (asprintf(&buf, "/mnt/stage2/%s", strrchr(directory, '/')) == -1) { logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__); abort(); } if (!access(buf, R_OK)) { logMessage(INFO, "can access %s", buf); rc = mountStage2(buf); if (rc == 0) { stage = NFS_STAGE_UPDATES; if (asprintf(&url, "nfs:%s:%s", host, directory) == -1) { logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__); abort(); } free(buf); break; } else { logMessage(WARNING, "unable to mount %s", buf); free(buf); break; } } else { logMessage(WARNING, "unable to access %s", buf); free(buf); umount("/mnt/stage2"); } } else { newtWinMessage(_("Error"), _("OK"), _("That directory could not be mounted from " "the server.")); if (loaderData->method >= 0) loaderData->method = -1; if (loaderData->inferredStage2) loaderData->invalidRepoParam = 1; break; } if (asprintf(&buf, _("That directory does not seem to " "contain a %s installation image."), getProductName()) == -1) { logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__); abort(); } newtWinMessage(_("Error"), _("OK"), buf); free(buf); if (loaderData->method >= 0) loaderData->method = -1; if (loaderData->inferredStage2) loaderData->invalidRepoParam = 1; break; } case NFS_STAGE_UPDATES: { char *buf; if (asprintf(&buf, "%.*s/RHupdates", (int) (strrchr(fullPath, '/')-fullPath), fullPath) == -1) { logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__); abort(); } logMessage(INFO, "mounting nfs path %s for updates", buf); if (!doPwMount(buf, "/tmp/update-disk", "nfs", mountOpts, NULL)) { logMessage(INFO, "Using RHupdates/ for NFS install"); copyDirectory("/tmp/update-disk", "/tmp/updates", NULL, NULL); umount("/tmp/update-disk"); unlink("/tmp/update-disk"); } else { logMessage(INFO, "No RHupdates/ directory found, skipping"); } stage = NFS_STAGE_DONE; break; } case NFS_STAGE_DONE: break; } } free(host); free(directory); if (fullPath) free(fullPath); return url; }
int main(int argc, char **argv) { if (argc < 2) return 1; if (argc == 2) return umount(argv[1]); return umount2(argv[1], atoi(argv[2])); }
int getFileFromNfs(char * url, char * dest, struct loaderData_s * loaderData) { char * host = NULL, *path = NULL, * file = NULL, * opts = NULL; char * chk = NULL, *ip = NULL; int failed = 0; iface_t iface; if (kickstartNetworkUp(loaderData, &iface)) { logMessage(ERROR, "unable to bring up network"); return 1; } /* if they just did 'linux ks', they want us to figure it out from * the dhcp/bootp information */ /* XXX: fixme NetworkManager integration */ /* if (url == NULL) { char ret[47]; ip_addr_t *tip; if (!(netCfg.dev.set & PUMP_INTFINFO_HAS_NEXTSERVER)) { logMessage(ERROR, "no bootserver was found"); return 1; } tip = &(netCfg.dev.nextServer); if (!(netCfg.dev.set & PUMP_INTFINFO_HAS_BOOTFILE)) { inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip)); if (asprintf(&url, "%s:%s", ret, "/kickstart/") == -1) { logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__); abort(); } logMessage(ERROR, "bootp: no bootfile received"); } else { inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip)); if (asprintf(&url, "%s:%s", ret, netCfg.dev.bootFile) == -1) { logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__); abort(); } logMessage(INFO, "bootp: bootfile is %s", netCfg.dev.bootFile); } } */ /* get the IP of the target system */ if ((ip = iface_ip2str(loaderData->netDev, AF_INET)) == NULL) { logMessage(ERROR, "nl_ip2str returned NULL"); return 1; } logMessage(INFO, "url is %s", url); getHostandPath(url, &host, &path, ip); opts = strchr(host, ':'); if (opts && (strlen(opts) > 1)) { char * c = opts; opts = host; host = c + 1; *c = '\0'; } else { opts = NULL; } /* nfs has to be a little bit different... split off the last part as * the file and then concatenate host + dir path */ file = strrchr(path, '/'); if (!file) { file = path; } else { *file++ ='\0'; chk = host + strlen(host)-1; if (*chk == '/' || *path == '/') { if (asprintf(&host, "%s%s", host, path) == -1) { logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__); abort(); } } else { if (asprintf(&host, "%s/%s", host, path) == -1) { logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__); abort(); } } } logMessage(INFO, "file location: nfs:%s/%s", host, file); if (!doPwMount(host, "/tmp/mnt", "nfs", opts, NULL)) { char * buf; if (asprintf(&buf, "/tmp/mnt/%s", file) == -1) { logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__); abort(); } if (copyFile(buf, dest)) { logMessage(ERROR, "failed to copy file to %s", dest); failed = 1; } free(buf); } else { logMessage(ERROR, "failed to mount nfs source"); failed = 1; } free(host); free(path); if (ip) free(ip); umount("/tmp/mnt"); unlink("/tmp/mnt"); return failed; }
void netfilter(const char *fname) { // default filter char *filter = client_filter; // custom filter int allocated = 0; if (fname) { // buffer the filter struct stat s; if (stat(fname, &s) == -1) { fprintf(stderr, "Error: cannot find network filter file\n"); exit(1); } filter = malloc(s.st_size + 1); // + '\0' memset(filter, 0, s.st_size + 1); if (!filter) errExit("malloc"); FILE *fp = fopen(fname, "r"); if (!fp) { fprintf(stderr, "Error: cannot open network filter file\n"); exit(1); } size_t sz = fread(filter, 1, s.st_size, fp); if (sz != s.st_size) { fprintf(stderr, "Error: cannot read network filter file\n"); exit(1); } fclose(fp); allocated = 1; } // mount a tempfs on top of /tmp directory if (mount("tmpfs", "/tmp", "tmpfs", MS_NOSUID | MS_STRICTATIME | MS_REC, "mode=755,gid=0") < 0) errExit("mounting /tmp"); // create the filter file FILE *fp = fopen("/tmp/netfilter", "w"); if (!fp) { fprintf(stderr, "Error: cannot open /tmp/netfilter file\n"); exit(1); } fprintf(fp, "%s\n", filter); fclose(fp); // push filter int rv; if (arg_debug) printf("Installing network filter:\n%s\n", filter); rv = system("/sbin/iptables-restore < /tmp/netfilter"); if (rv == -1) { fprintf(stderr, "Error: failed to configure network filter.\n"); exit(1); } if (arg_debug) rv = system("/sbin/iptables -vL"); // unmount /tmp umount("/tmp"); if (allocated) free(filter); }
int ensure_dev_unmounted(const char * mountedPoint){ int ret = umount(mountedPoint); return ret; }
void unregister_bdev(struct bdev *bdev) { umount(bdev->mount); bdev->ops = NULL; }
/* * Mount point for selinuxfs. * This definition is private to the function below. * Everything else uses the location determined during * libselinux startup via /proc/mounts (see init_selinuxmnt). * We only need the hardcoded definition for the initial mount * required for the initial policy load. */ int selinux_init_load_policy(int *enforce) { int rc = 0, orig_enforce = 0, seconfig = -2, secmdline = -1; FILE *cfg; char *buf; /* * Reread the selinux configuration in case it has changed. * Example: Caller has chroot'd and is now loading policy from * chroot'd environment. */ selinux_reset_config(); /* * Get desired mode (disabled, permissive, enforcing) from * /etc/selinux/config. */ selinux_getenforcemode(&seconfig); /* Check for an override of the mode via the kernel command line. */ rc = mount("proc", "/proc", "proc", 0, 0); cfg = fopen("/proc/cmdline", "r"); if (cfg) { char *tmp; buf = malloc(selinux_page_size); if (!buf) { fclose(cfg); return -1; } if (fgets(buf, selinux_page_size, cfg) && (tmp = strstr(buf, "enforcing="))) { if (tmp == buf || isspace(*(tmp - 1))) { secmdline = atoi(tmp + sizeof("enforcing=") - 1); } } fclose(cfg); free(buf); } #ifndef MNT_DETACH #define MNT_DETACH 2 #endif if (rc == 0) umount2("/proc", MNT_DETACH); /* * Determine the final desired mode. * Command line argument takes precedence, then config file. */ if (secmdline >= 0) *enforce = secmdline; else if (seconfig >= 0) *enforce = seconfig; else *enforce = 0; /* unspecified or disabled */ /* * Check for the existence of SELinux via selinuxfs, and * mount it if present for use in the calls below. */ if (mount("selinuxfs", SELINUXMNT, "selinuxfs", 0, 0) < 0 && errno != EBUSY) { if (errno == ENODEV) { /* * SELinux was disabled in the kernel, either * omitted entirely or disabled at boot via selinux=0. * This takes precedence over any config or * commandline enforcing setting. */ *enforce = 0; } else { /* Only emit this error if selinux was not disabled */ fprintf(stderr, "Mount failed for selinuxfs on %s: %s\n", SELINUXMNT, strerror(errno)); } goto noload; } set_selinuxmnt(SELINUXMNT); /* * Note: The following code depends on having selinuxfs * already mounted and selinuxmnt set above. */ if (seconfig == -1) { /* Runtime disable of SELinux. */ rc = security_disable(); if (rc == 0) { /* Successfully disabled, so umount selinuxfs too. */ umount(SELINUXMNT); fini_selinuxmnt(); } /* * If we failed to disable, SELinux will still be * effectively permissive, because no policy is loaded. * No need to call security_setenforce(0) here. */ goto noload; } /* * If necessary, change the kernel enforcing status to match * the desired mode. */ orig_enforce = rc = security_getenforce(); if (rc < 0) goto noload; if (orig_enforce != *enforce) { rc = security_setenforce(*enforce); if (rc < 0) { fprintf(stderr, "SELinux: Unable to switch to %s mode: %s\n", (*enforce ? "enforcing" : "permissive"), strerror(errno)); if (*enforce) goto noload; } } /* Load the policy. */ return selinux_mkload_policy(0); noload: /* * Only return 0 on a successful completion of policy load. * In any other case, we want to return an error so that init * knows not to proceed with the re-exec for the domain transition. * Depending on the *enforce setting, init will halt (> 0) or proceed * normally (otherwise). */ return -1; }
int init_main(int argc, char *argv[]) { for (int i = 1; i < argc; ++i) { if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) { init_usage(true); return EXIT_SUCCESS; } } umask(0); mkdir("/dev", 0755); mkdir("/proc", 0755); mkdir("/sys", 0755); mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755"); mkdir("/dev/pts", 0755); mkdir("/dev/socket", 0755); mount("devpts", "/dev/pts", "devpts", 0, nullptr); mount("proc", "/proc", "proc", 0, nullptr); mount("sysfs", "/sys", "sysfs", 0, nullptr); open_devnull_stdio(); util::log_set_logger(std::make_shared<util::KmsgLogger>()); if (klogctl(KLOG_CONSOLE_LEVEL, nullptr, 8) < 0) { LOGE("Failed to set loglevel: %s", strerror(errno)); } LOGV("Booting up with version %s (%s)", get_mbtool_version(), get_git_version()); // Start probing for devices device_init(); std::string fstab = find_fstab(); if (fstab.empty()) { LOGE("Failed to find a suitable fstab file"); emergency_reboot(); return EXIT_FAILURE; } mkdir("/system", 0755); mkdir("/cache", 0770); mkdir("/data", 0771); util::chown("/cache", "system", "cache", 0); util::chown("/data", "system", "system", 0); fix_arter97(); // Mount fstab and write new redacted version if (!mount_fstab(fstab, true)) { LOGE("Failed to mount fstab"); emergency_reboot(); return EXIT_FAILURE; } LOGE("Successfully mounted fstab"); fix_file_contexts(); add_mbtool_services(); strip_manual_mounts(); struct stat sb; if (stat("/sepolicy", &sb) == 0) { if (!patch_sepolicy("/sepolicy", "/sepolicy")) { LOGW("Failed to patch /sepolicy"); emergency_reboot(); return EXIT_FAILURE; } } // Kill uevent thread and close uevent socket device_close(); // Unmount partitions umount("/dev/pts"); umount("/dev"); umount("/proc"); umount("/sys"); // Do not remove these as Android 6.0 init's stage 1 no longer creates these // (platform/system/core commit a1f6a4b13921f61799be14a2544bdbf95958eae7) //rmdir("/dev"); //rmdir("/proc"); //rmdir("/sys"); // Start real init unlink("/init"); rename("/init.orig", "/init"); LOGD("Launching real init ..."); execlp("/init", "/init", nullptr); LOGE("Failed to exec real init: %s", strerror(errno)); emergency_reboot(); return EXIT_FAILURE; }
int main(int ac, char **av) { int lc, i; /* loop counter */ char *msg; /* message returned from parse_opts */ /* parse standard options */ if ((msg = parse_opts(ac, av, options, &help)) != NULL) { tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); tst_exit(); } /* Check for mandatory option of the testcase */ if (Dflag == 0) { tst_brkm(TBROK, NULL, "You must specifiy the device used for " " mounting with -D option, Run '%s -h' for option " " information.", TCID); tst_exit(); } Type = (char *)malloc(FSTYPE_LEN); if (!Type) { tst_brkm(TBROK, NULL, "malloc - alloc of %d failed", FSTYPE_LEN); tst_exit(); } if (Tflag == 1) { strncpy(Type, fstype, (FSTYPE_LEN < (strlen(fstype)+1)) ? FSTYPE_LEN : (strlen(fstype)+1)); } else { strncpy(Type, DEFAULT_FSTYPE, strlen(DEFAULT_FSTYPE)+1); } if (STD_COPIES != 1) { tst_resm(TINFO, "-c option has no effect for this testcase - " "%s doesn't allow running more than one instance " "at a time", TCID); STD_COPIES = 1; } setup(); for (lc = 0; TEST_LOOPING(lc); lc++) { Tst_count = 0; for (i = 0; i < TST_TOTAL; ++i) { if (setup_test(i, lc)) { tst_resm(TWARN, "Not able to test mount(2) for " "error %s as setup failed", testcases[i].exp_errval); continue; } /* Call umount(2) to test different test conditions. * verify that it fails with -1 return value and * sets appropriate errno.*/ TEST(umount(Mntpoint)); /* check return code */ if ((TEST_RETURN == -1) && (TEST_ERRNO == testcases[i].exp_errno)) { tst_resm(TPASS, "umount(2) expected failure; " "Got errno - %s : %s", testcases[i].exp_errval, testcases[i].err_desc); } else { tst_resm(TFAIL, "umount(2) failed to produce " "expected error; %d, errno:%s got %d", testcases[i].exp_errno, testcases[i].exp_errval, TEST_ERRNO); } TEST_ERROR_LOG(TEST_ERRNO); (void)cleanup_test(i); } } /* cleanup and exit */ cleanup(); tst_exit(); }
int bootup_main(int argc, char **argv) { FILE *fp; DIR *dp; struct dirent *dt; int t=0, rc; char cmd[1024], buf[1024], name[1024]; time_t curtime; struct tm *loctime; signal(SIGINT,SIG_IGN); putenv("PATH=/bin"); putenv("TERM=linux"); umask(0770); chdir("/"); putchar('\n'); print_banner(); putchar('\n'); xsystem("mount -t proc -o ro virtual /proc"); xsystem("mount -t sysfs -o ro virtual /sys"); // STAGE 1 calculate_mem(); fprintf_stdout("* Creating Mybox filesystem (%d kB) on shared memory...\n",RAMSIZE); xsystem("mount -t tmpfs -o \"rw,size=%dk\" virtual /ramd",RAMSIZE); chmod("/ramd",S_IREAD | S_IWRITE | S_IEXEC); chdir("/ramd"); if((dp=opendir("/")) == NULL) { perror("opendir"); exit(1); } while((dt=readdir(dp))!=NULL) { if(!strcmp(dt->d_name,".") || !strcmp(dt->d_name,"..") || !strcmp(dt->d_name,"lost+found") || !strcmp(dt->d_name,"ramd") || !strcmp(dt->d_name,"proc") || !strcmp(dt->d_name,"dev") || !strcmp(dt->d_name,"sys")) continue; xsystem("cp -dpR /%s /ramd/",dt->d_name); } closedir(dp); xmkdir("dev/pts"); xmkdir("initrd"); umount("/proc"); umount("/sys"); // STAGE 2 rc=pivot_root(".","initrd"); if(rc==-1) { fprintf_stdout("#### ERROR: Change root file system failed!\n"); exit(1); } chdir("/"); xmkdir("proc"); xmkdir("sys"); xsystem("mount -t proc -o rw virtual /proc"); xsystem("mount -t sysfs -o rw virtual /sys"); save_to_file("/proc/sys/kernel/printk","0 0 0 0\n"); if((dp=opendir("/tmp")) == NULL) { perror("opendir"); exit(1); } fprintf_stdout("-> Extracting base tools: "); while((dt=readdir(dp))!=NULL) { if(!strcmp(dt->d_name,".") || !strcmp(dt->d_name,"..")) continue; if(strstr(dt->d_name,".mpk")) { fprintf_stdout("#"); xsystem("tar -C / -axf /tmp/%s",dt->d_name); } } free(dt); closedir(dp); fprintf_stdout("\r* Extracting base tools. Done.%s\n",SPACE); save_to_file("/proc/sys/kernel/modprobe","/bin/modprobe\n"); xsystem("depmod -a"); // STAGE 3 chdir("/"); xsystem("mdev -s"); xsystem("mount -t devpts /dev/devpts /dev/pts -o \"rw,gid=0,mode=620\""); rename("/dev/random","/dev/random-block"); symlink("/dev/urandom","/dev/random"); xsystem("chmod 700 *"); if((fp=fopen("/etc/inittab","w"))!=NULL) { fprintf(fp,"::sysinit:/etc/init.boot/rc.init\n"); fprintf(fp,"tty1::respawn:/bin/getty -h -n -L tty1 115200 linux\n"); fprintf(fp,"ttyS0::respawn:/bin/getty -h -n -L ttyS0 115200 vt100\n"); fprintf(fp,"tty7::respawn:/bin/chkprog\n"); fprintf(fp,"tty8::respawn:/bin/trafficd\n"); fprintf(fp,"::restart:/bin/init\n"); fprintf(fp,"::ctrlaltdel:/bin/bootdown\n"); fprintf(fp,"::ctrlaltdel:/bin/reset\n"); fprintf(fp,"::ctrlaltdel:/bin/reboot\n"); fprintf(fp,"::shutdown:/bin/bootdown\n"); fclose(fp); } curtime=time(NULL); loctime=localtime(&curtime); strftime(cmd, sizeof(cmd), "[%d/%m/%Y %T] TYPE=INFO MSG=****** SYSTEM LOADING ******\n",loctime); append_to_file("/tmp/bootup",cmd); if(file_exists("/bin/getkey")) { if(system("getkey -c 3 -m \"-> Starting Init: %d\" R")==0) { fprintf_stdout("\r#### WARNING: LOGIN DISABLED\n"); xtouch("/etc/noconsole"); } else { fprintf_stdout("\r* Starting Init. Done.\n"); } } memset(buf,0x0,sizeof(buf)); snprintf(buf,sizeof(buf),"%s\n","/bin/mdev"); save_to_file("/proc/sys/kernel/hotplug",buf); do_chroot(); signal(SIGINT,SIG_DFL); fprintf_stdout("#### ERROR: Failed to boot file system!\n"); fprintf_stdout("#### ERROR: Press Ctrl+Alt+Del or switch off/on for reboot.\n"); while(1); exit(0); }
static void check_fs(char *blk_device, char *fs_type, char *target) { int status; int ret; long tmpmnt_flags = MS_NOATIME | MS_NOEXEC | MS_NOSUID; char *tmpmnt_opts = "nomblk_io_submit,errors=remount-ro"; char *e2fsck_argv[] = { E2FSCK_BIN, "-y", blk_device }; /* Check for the types of filesystems we know how to check */ if (!strcmp(fs_type, "ext2") || !strcmp(fs_type, "ext3") || !strcmp(fs_type, "ext4")) { /* * First try to mount and unmount the filesystem. We do this because * the kernel is more efficient than e2fsck in running the journal and * processing orphaned inodes, and on at least one device with a * performance issue in the emmc firmware, it can take e2fsck 2.5 minutes * to do what the kernel does in about a second. * * After mounting and unmounting the filesystem, run e2fsck, and if an * error is recorded in the filesystem superblock, e2fsck will do a full * check. Otherwise, it does nothing. If the kernel cannot mount the * filesytsem due to an error, e2fsck is still run to do a full check * fix the filesystem. */ ret = mount(blk_device, target, fs_type, tmpmnt_flags, tmpmnt_opts); INFO("%s(): mount(%s,%s,%s)=%d\n", __func__, blk_device, target, fs_type, ret); if (!ret) { umount(target); } /* * Some system images do not have e2fsck for licensing reasons * (e.g. recent SDK system images). Detect these and skip the check. */ if (access(E2FSCK_BIN, X_OK)) { INFO("Not running %s on %s (executable not in system image)\n", E2FSCK_BIN, blk_device); } else { INFO("Running %s on %s\n", E2FSCK_BIN, blk_device); ret = android_fork_execvp_ext(ARRAY_SIZE(e2fsck_argv), e2fsck_argv, &status, true, LOG_KLOG | LOG_FILE, true, FSCK_LOG_FILE); if (ret < 0) { /* No need to check for error in fork, we can't really handle it now */ ERROR("Failed trying to run %s\n", E2FSCK_BIN); } } } else if (!strcmp(fs_type, "f2fs")) { char *f2fs_fsck_argv[] = { F2FS_FSCK_BIN, blk_device }; INFO("Running %s on %s\n", F2FS_FSCK_BIN, blk_device); ret = android_fork_execvp_ext(ARRAY_SIZE(f2fs_fsck_argv), f2fs_fsck_argv, &status, true, LOG_KLOG | LOG_FILE, true, FSCK_LOG_FILE); if (ret < 0) { /* No need to check for error in fork, we can't really handle it now */ ERROR("Failed trying to run %s\n", F2FS_FSCK_BIN); } } return; }
int unmount_mounted_volume(const MountedVolume *volume) { /* Intentionally pass NULL to umount if the caller tries * to unmount a volume they already unmounted using this * function. */ int ret = umount(volume->mount_point); if (ret == 0) { free_volume_internals(volume, 1); return 0; } #if 1 //wschen 2012-10-23 else { DIR *dir, *dir1; int fd; int len, len1; char buf[1024]; char buf1[1024]; char pid[1024]; char file_path[1024]; struct dirent *ptr, *ptr1; printf("%s\n", strerror(errno)); dir = opendir("/proc/"); if (dir) { while ((ptr = readdir(dir)) != NULL) { if (ptr->d_name[0] >= '0' && ptr->d_name[0] <= '9') { snprintf(pid, sizeof(pid), "/proc/%s/cmdline", ptr->d_name); fd = open(pid, O_RDONLY); len1 = 0; if (fd) { len1 = read(fd, buf1, sizeof(buf1)); close(fd); snprintf(pid, sizeof(pid), "/proc/%s/fd", ptr->d_name); dir1 = opendir(pid); if (dir1) { while ((ptr1 = readdir(dir1)) != NULL) { snprintf(file_path, sizeof(file_path), "/proc/%s/fd/%s", ptr->d_name, ptr1->d_name); len = readlink(file_path, buf, sizeof(buf)); if (len != -1) { buf[len] = '\0'; if (strstr(buf, volume->mount_point) == buf) { if (len1) { printf("process(%s):%s\n", ptr->d_name, buf1); } printf("found:%s\n", buf); } } } closedir(dir1); } } } } closedir(dir); } } #endif return ret; }
int VolumeManager::unmountLoopImage(const char *id, const char *idHash, const char *fileName, const char *mountPoint, bool force) { if (!isMountpointMounted(mountPoint)) { SLOGE("Unmount request for %s when not mounted", id); errno = ENOENT; return -1; } int i, rc; for (i = 1; i <= UNMOUNT_RETRIES; i++) { rc = umount(mountPoint); if (!rc) { break; } if (rc && (errno == EINVAL || errno == ENOENT)) { SLOGI("Container %s unmounted OK", id); rc = 0; break; } SLOGW("%s unmount attempt %d failed (%s)", id, i, strerror(errno)); int action = 0; // default is to just complain if (force) { if (i > (UNMOUNT_RETRIES - 2)) action = 2; // SIGKILL else if (i > (UNMOUNT_RETRIES - 3)) action = 1; // SIGHUP } Process::killProcessesWithOpenFiles(mountPoint, action); usleep(UNMOUNT_SLEEP_BETWEEN_RETRY_MS); } if (rc) { errno = EBUSY; SLOGE("Failed to unmount container %s (%s)", id, strerror(errno)); return -1; } int retries = 10; while(retries--) { if (!rmdir(mountPoint)) { break; } SLOGW("Failed to rmdir %s (%s)", mountPoint, strerror(errno)); usleep(UNMOUNT_SLEEP_BETWEEN_RETRY_MS); } if (!retries) { SLOGE("Timed out trying to rmdir %s (%s)", mountPoint, strerror(errno)); } if (Devmapper::destroy(idHash) && errno != ENXIO) { SLOGE("Failed to destroy devmapper instance (%s)", strerror(errno)); } char loopDevice[255]; if (!Loop::lookupActive(idHash, loopDevice, sizeof(loopDevice))) { Loop::destroyByDevice(loopDevice); } else { SLOGW("Failed to find loop device for {%s} (%s)", fileName, strerror(errno)); } AsecIdCollection::iterator it; for (it = mActiveContainers->begin(); it != mActiveContainers->end(); ++it) { ContainerData* cd = *it; if (!strcmp(cd->id, id)) { free(*it); mActiveContainers->erase(it); break; } } if (it == mActiveContainers->end()) { SLOGW("mActiveContainers is inconsistent!"); } return 0; }
int format_volume(const char* volume) { Volume* v = volume_for_path(volume); if (v == NULL) { LOGE("unknown volume \"%s\"\n", volume); return -1; } if (strcmp(v->fs_type, "ramdisk") == 0) { // you can't format the ramdisk. LOGE("can't format_volume \"%s\"", volume); return -1; } if (strcmp(v->mount_point, volume) != 0) { LOGE("can't give path \"%s\" to format_volume\n", volume); return -1; } if (ensure_path_unmounted(volume) != 0) { LOGE("format_volume failed to unmount \"%s\"\n", v->mount_point); return -1; } if(!strcmp(v->fs_type, "ubifs")) { const MtdPartition *partition; mtd_scan_partitions(); if(strcmp(v->mount_point, "/data")) partition = mtd_find_partition_by_name(&v->mount_point[1]); else partition = mtd_find_partition_by_name("userdata"); if (partition == NULL) { LOGE("format_volume: %s cat't find mtd partition\n", v->mount_point); return -1; }else{ if (strcmp(v->mount_point, "/system") == 0 || strcmp(v->mount_point, "/cache") == 0 || strcmp(v->mount_point, "/data") == 0 ){ char cmd_line[128]; int ubi_vol = 1; // bool b_org_mounted = false; int status; ui_print("format partition: %s \n", v->mount_point); #if 1 if (strcmp(v->mount_point, "/system") == 0){ ubi_vol = 1; }else if (strcmp(v->mount_point, "/data") == 0){ ubi_vol = 2; }else if(strcmp(v->mount_point, "/cache") == 0){ ubi_vol = 3; }else{ ubi_vol = 4; //perm partition } #endif //vapor : it is not properly, so we mask it. //if (ensure_path_mounted(v->mount_point) == 0) { fprintf(stderr,"umount /%s\r\n", v->mount_point); umount(v->mount_point); } memset(cmd_line, 0, 128); sprintf(cmd_line, "/format.sh %d %d %s", partition->device_index, ubi_vol, partition->name); format_ubifs(cmd_line); ui_print("format partition: %s complete\n", v->device); return 0; } } } else if (strcmp(v->fs_type, "yaffs2") == 0 || strcmp(v->fs_type, "mtd") == 0) { mtd_scan_partitions(); const MtdPartition* partition = mtd_find_partition_by_name(v->device); if (partition == NULL) { LOGE("format_volume: no MTD partition \"%s\"\n", v->device); return -1; } MtdWriteContext *write = mtd_write_partition(partition); if (write == NULL) { LOGW("format_volume: can't open MTD \"%s\"\n", v->device); return -1; } else if (mtd_erase_blocks(write, -1) == (off_t) -1) { LOGW("format_volume: can't erase MTD \"%s\"\n", v->device); mtd_write_close(write); return -1; } else if (mtd_write_close(write)) { LOGW("format_volume: can't close MTD \"%s\"\n", v->device); return -1; } return 0; } #if 0 else if (strcmp(v->fs_type, "ext4") == 0) { int result = make_ext4fs(v->device, v->length); if (result != 0) { LOGE("format_volume: make_extf4fs failed on %s\n", v->device); return -1; } return 0; } #endif LOGE("format_volume: fs_type \"%s\" unsupported\n", v->fs_type); return -1; }
int ldiskfs_rename_fsname(struct mkfs_opts *mop, const char *oldname) { struct mount_opts opts; struct lustre_disk_data *ldd = &mop->mo_ldd; char mntpt[] = "/tmp/mntXXXXXX"; char *dev; int ret; /* Change the filesystem label. */ opts.mo_ldd = *ldd; opts.mo_source = mop->mo_device; ret = ldiskfs_label_lustre(&opts); if (ret) { if (errno != 0) ret = errno; fprintf(stderr, "Can't change filesystem label: %s\n", strerror(ret)); return ret; } /* Mount this device temporarily in order to write these files */ if (mkdtemp(mntpt) == NULL) { if (errno != 0) ret = errno; else ret = EINVAL; fprintf(stderr, "Can't create temp mount point %s: %s\n", mntpt, strerror(ret)); return ret; } #ifdef HAVE_SELINUX /* * Append file context to mount options if SE Linux is enabled */ if (is_selinux_enabled() > 0) append_context_for_mount(mntpt, mop); #endif if (mop->mo_flags & MO_IS_LOOP) dev = mop->mo_loopdev; else dev = mop->mo_device; ret = mount(dev, mntpt, MT_STR(ldd), 0, ldd->ldd_mount_opts); if (ret) { if (errno != 0) ret = errno; fprintf(stderr, "Unable to mount %s: %s\n", dev, strerror(ret)); if (ret == ENODEV) fprintf(stderr, "Is the %s module available?\n", MT_STR(ldd)); goto out_rmdir; } ret = lustre_rename_fsname(mop, mntpt, oldname); umount(mntpt); out_rmdir: rmdir(mntpt); return ret; }
int main(int argc, char **argv) { /* TODO: Add functionality to rmdir new_root, possibly create a subdir to * hide it from other users. */ const char *new_root; const char *env[] = { NULL, NULL }; int got, i, fd, pid, pid2, pfd[2], status; int okc, failc; DIR *dir; FILE *f; char *p, *q; struct dirent *dirent; /* Parse command-line */ (void)argc; if (argv[1] == NULL) { fprintf(stderr, "Usage: %s <new-root> [<command> [<arg>]]\n", argv[0]); return 1; } if (strlen(argv[1]) > sizeof(buf) - 10) { fprintf(stderr, "error: name of new_root too long\n"); return 2; } new_root = argv[1]; p = getenv("TERM"); if (p != NULL) { /* TODO: Find it in environ manually, so env_buf is not needed. */ strcpy(env_buf, "TERM="); if (strlen(p) >= sizeof(env_buf) - 5) { fprintf(stderr, "error: TERM too long\n"); return 2; } strncpy(env_buf + 5, p, sizeof(env_buf) - 5); env_buf[sizeof(env_buf) - 1] = '\0'; /* Just for extra safety. */ env[0] = env_buf; } fd = open(new_root, O_RDONLY | O_DIRECTORY); /* Can open a directory. */ if (fd < 0) { perror("open new_root"); return 2; } got = umount(new_root); if (got == 0) { /* Can't succeed, we have fd open. */ fprintf(stderr, "error: unexpected umount success\n"); return 2; } if (errno == EINVAL) { /* TODO: Detect that new_root is a mount point. */ fprintf(stderr, "error: new_root is not mounted\n"); return 2; } if (errno != EBUSY) { perror("umount1"); return 2; } close(fd); got = pipe(pfd); if (got != 0) { perror("pipe"); return 2; } pid = fork(); if (pid < 0) { perror("fork"); return 2; } if (pid == 0) { /* Child: will umount new_root outside. */ char c; close(pfd[1]); got = read(pfd[0], &c, 1); /* Wait for parent to activate us. */ if (got != 0) { if (got == 0) return 0; perror("read pfd"); return 2; } got = umount(new_root); if (got != 0) { perror("umount child"); return 2; } return 0; } close(pfd[0]); /* umount is needed otherwise the child won't be able to umount new_root. * TODO: Umount everything in new_root. */ /* buf is long enough, we've checked that */ strcpy(buf, new_root); /* TODO: Use snprintf for extra safety. */ strcat(buf, "/proc"); umount(buf); /* Don't check the result. */ got = syscall(SYS_unshare, CLONE_NEWNS); if (got != 0) { perror("unshare"); return 2; } got = chdir(new_root); if (got != 0) { perror("chdir1"); return 2; } mkdir("put_old", 0700); /* Don't check the result. */ got = syscall(SYS_pivot_root, ".", "put_old"); if (got != 0) { /* TODO: Report nice error if put_old is not a directory. */ /* See restrictions is `man 2 pivot_root' for possible error reasons. */ perror("pivot_root"); return 2; } got = chroot("."); if (got != 0) { perror("chroot"); return 2; } got = chdir("/"); if (got != 0) { perror("chdir2"); return 2; } close(pfd[1]); /* Activate the child, who will umount(new_root). */ /* Wait for the child to finish the umount. */ pid2 = waitpid(pid, &status, 0); if (pid2 < 0) { perror("waitpid"); return 2; } if (pid != pid2) { fprintf(stderr, "error: unexpected child exit\n"); return 2; } if (status != 0) { fprintf(stderr, "error: child failed with status=0x%x\n", status); return 2; } umount("/proc"); /* Don't check the result. */ mkdir("/proc", 0755); /* Don't check the result. */ got = mount("none", "/proc", "proc", 0, NULL); if (got != 0) { perror("mount /proc"); return 2; } /* Close all file descriptors other than 0, 1 and 2 (/proc/self/fd). */ dir = opendir("/proc/self/fd"); if (dir == NULL) { perror("opendir /proc/self/fd"); return 2; } fd = dirfd(dir); while (NULL != (dirent = readdir(dir))) { if (1 == sscanf(dirent->d_name, "%d", &i) && i != fd && i > 2) { close(i); /* Don't check the result. */ } } closedir(dir); /* Umount all filesystems in put_old. */ do { okc = 0; failc = 0; f = fopen("/proc/mounts", "r"); if (f == NULL) { perror("fopen /proc/mounts"); return 2; } while (NULL != (p = fgets(buf, sizeof(buf) - 1, f))) { if (buf[0] == '\0' || buf[strlen(buf) - 1] != '\n') { fprintf(stderr, "error: mounts line empty or too long\n"); return 2; } p = buf; while (p[0] != '\0' && p[0] != ' ' && p[0] != '\n') { ++p; } while (p[0] == ' ') { ++p; } if (p[0] == '\0' || p[0] == '\n') { fprintf(stderr, "error: mounts mount point not found: %s", buf); return 2; } q = p; while (q[0] != '\0' && q[0] != ' ') { ++q; } if (q[0] == '\0' || q[0] == '\n') { /* No \n. */ fprintf(stderr, "error: mounts mount point ends: %s", buf); return 2; } q[0] = '\0'; if (0 == strncmp(p, "/put_old", 8) && (p[8] == '/' || p[8] == '\0')) { if (umount(p) != 0) { /* It's OK to fail here, because some filesystems are inside * each other, and we may try to umount the outer filesystem first. */ /* TODO: Sort by the number of slashes. */ ++failc; } else { ++okc; } } } if (ferror(f)) { fprintf(stderr, "error: reading mounts\n"); return 2; } fclose(f); } while (okc > 0 && failc > 0); /* Try to make more progress umounting. */ if (failc > 0) { fprintf(stderr, "error: could not umount put_old\n"); return 2; } got = rmdir("/put_old"); if (got != 0) { perror("rmdir put_old"); return 2; } if (argv[2] == NULL) { got = execle("/bin/sh", "sh", "-i", NULL, env); } else { got = execve(argv[2], argv + 2, (void*)env); } if (got != 0) { perror("execl"); return 2; } return 0; }