static ssize_t snapshot_read(struct file *filp, char __user *buf, size_t count, loff_t *offp) { struct snapshot_data *data; ssize_t res; mutex_lock(&pm_mutex); data = filp->private_data; if (!data->ready) { res = -ENODATA; goto Unlock; } res = snapshot_read_next(&data->handle, count); if (res > 0) { if (copy_to_user(buf, data_of(data->handle), res)) res = -EFAULT; else *offp = data->handle.offset; } Unlock: mutex_unlock(&pm_mutex); return res; }
static ssize_t snapshot_read(struct file *filp, char __user *buf, size_t count, loff_t *offp) { struct snapshot_data *data; ssize_t res; loff_t pg_offp = *offp & ~PAGE_MASK; mutex_lock(&pm_mutex); data = filp->private_data; if (!data->ready) { res = -ENODATA; goto Unlock; } if (!pg_offp) { /* on page boundary? */ res = snapshot_read_next(&data->handle); if (res <= 0) goto Unlock; } else { res = PAGE_SIZE - pg_offp; } res = simple_read_from_buffer(buf, count, &pg_offp, data_of(data->handle), res); if (res > 0) *offp += res; Unlock: mutex_unlock(&pm_mutex); return res; }
static ssize_t snapshot_write(struct file *filp, const char __user *buf, size_t count, loff_t *offp) { struct snapshot_data *data; ssize_t res; loff_t pg_offp = *offp & ~PAGE_MASK; mutex_lock(&pm_mutex); data = filp->private_data; if (!pg_offp) { res = snapshot_write_next(&data->handle); if (res <= 0) goto unlock; } else { res = PAGE_SIZE - pg_offp; } res = simple_write_to_buffer(data_of(data->handle), res, &pg_offp, buf, count); if (res > 0) *offp += res; unlock: mutex_unlock(&pm_mutex); return res; }
static int load_image(struct swap_map_handle *handle, struct snapshot_handle *snapshot, unsigned int nr_pages) { unsigned int m; int ret; int error = 0; printk("Loading image data pages (%u pages) ... ", nr_pages); m = nr_pages / 100; if (!m) m = 1; nr_pages = 0; do { ret = snapshot_write_next(snapshot, PAGE_SIZE); if (ret > 0) { error = swap_read_page(handle, data_of(*snapshot)); if (error) break; if (!(nr_pages % m)) printk("\b\b\b\b%3d%%", nr_pages / m); nr_pages++; } } while (ret > 0); if (!error) { printk("\b\b\b\bdone\n"); if (!snapshot_image_loaded(snapshot)) error = -ENODATA; } return error; }
int swsusp_read(void) { int error; struct swap_map_handle handle; struct snapshot_handle snapshot; struct swsusp_info *header; if (IS_ERR(resume_bdev)) { pr_debug("swsusp: block device not initialised\n"); return PTR_ERR(resume_bdev); } memset(&snapshot, 0, sizeof(struct snapshot_handle)); error = snapshot_write_next(&snapshot, PAGE_SIZE); if (error < PAGE_SIZE) return error < 0 ? error : -EFAULT; header = (struct swsusp_info *)data_of(snapshot); error = get_swap_reader(&handle, swsusp_header.image); if (!error) error = swap_read_page(&handle, header); if (!error) error = load_image(&handle, &snapshot, header->pages - 1); release_swap_reader(&handle); blkdev_put(resume_bdev); if (!error) pr_debug("swsusp: Reading resume file was successful\n"); else pr_debug("swsusp: Error %d resuming\n", error); return error; }
int swsusp_read(unsigned int *flags_p) { int error; struct swap_map_handle handle; struct snapshot_handle snapshot; struct swsusp_info *header; *flags_p = swsusp_header->flags; if (IS_ERR(resume_bdev)) { pr_debug("PM: Image device not initialised\n"); return PTR_ERR(resume_bdev); } memset(&snapshot, 0, sizeof(struct snapshot_handle)); error = snapshot_write_next(&snapshot, PAGE_SIZE); if (error < PAGE_SIZE) return error < 0 ? error : -EFAULT; header = (struct swsusp_info *)data_of(snapshot); error = get_swap_reader(&handle, swsusp_header->image); if (!error) error = swap_read_page(&handle, header, NULL); if (!error) error = load_image(&handle, &snapshot, header->pages - 1); release_swap_reader(&handle); if (!error) pr_debug("PM: Image successfully loaded\n"); else pr_debug("PM: Error %d resuming\n", error); return error; }
static void eval(struct gmi_model* m, struct gmi_ent* e, double const p[2], double x[3]) { struct gmi_analytic* m2; struct agm_ent a; void* u; gmi_analytic_fun f; m2 = to_model(m); a = agm_from_gmi(e); u = *(data_of(m2, a)); f = *(f_of(m2, a)); (*f)(p, x, u); }
int swsusp_write(unsigned int flags) { struct swap_map_handle handle; struct snapshot_handle snapshot; struct swsusp_info *header; int error; error = swsusp_swap_check(); if (error) { printk(KERN_ERR "PM: Cannot find swap device, try " "swapon -a.\n"); return error; } memset(&snapshot, 0, sizeof(struct snapshot_handle)); error = snapshot_read_next(&snapshot, PAGE_SIZE); if (error < PAGE_SIZE) { if (error >= 0) error = -EFAULT; goto out; } header = (struct swsusp_info *)data_of(snapshot); if (!enough_swap(header->pages)) { printk(KERN_ERR "PM: Not enough free swap\n"); error = -ENOSPC; goto out; } error = get_swap_writer(&handle); if (!error) { sector_t start = handle.cur_swap; error = swap_write_page(&handle, header, NULL); if (!error) error = save_image(&handle, &snapshot, header->pages - 1); if (!error) { flush_swap_writer(&handle); printk(KERN_INFO "PM: S"); error = mark_swapfiles(start, flags); printk("|\n"); } } if (error) free_all_swap_pages(root_swap); release_swap_writer(&handle); out: swsusp_close(FMODE_WRITE); return error; }
static int load_image(struct swap_map_handle *handle, struct snapshot_handle *snapshot, unsigned int nr_to_read) { unsigned int m; int error = 0; struct timeval start; struct timeval stop; struct bio *bio; int err2; unsigned nr_pages; printk(KERN_INFO "PM: Loading image data pages (%u pages) ... ", nr_to_read); m = nr_to_read / 100; if (!m) m = 1; nr_pages = 0; bio = NULL; do_gettimeofday(&start); for ( ; ; ) { error = snapshot_write_next(snapshot, PAGE_SIZE); if (error <= 0) break; error = swap_read_page(handle, data_of(*snapshot), &bio); if (error) break; if (snapshot->sync_read) error = hib_wait_on_bio_chain(&bio); if (error) break; if (!(nr_pages % m)) printk("\b\b\b\b%3d%%", nr_pages / m); nr_pages++; } err2 = hib_wait_on_bio_chain(&bio); do_gettimeofday(&stop); if (!error) error = err2; if (!error) { printk("\b\b\b\bdone\n"); snapshot_write_finalize(snapshot); if (!snapshot_image_loaded(snapshot)) error = -ENODATA; } else printk("\n"); swsusp_show_speed(&start, &stop, nr_to_read, "Read"); return error; }
static ssize_t snapshot_write(struct file *filp, const char __user *buf, size_t count, loff_t *offp) { struct snapshot_data *data; ssize_t res; data = filp->private_data; res = snapshot_write_next(&data->handle, count); if (res > 0) { if (copy_from_user(data_of(data->handle), buf, res)) res = -EFAULT; else *offp = data->handle.offset; } return res; }
static int save_image(struct swap_map_handle *handle, struct snapshot_handle *snapshot, unsigned int nr_to_write) { unsigned int m; int ret; int nr_pages; int err2; struct bio *bio; struct timeval start; struct timeval stop; printk(KERN_INFO "PM: Saving image data pages (%u pages) ... ", nr_to_write); m = nr_to_write / 100; if (!m) m = 1; nr_pages = 0; bio = NULL; do_gettimeofday(&start); while (1) { ret = snapshot_read_next(snapshot, PAGE_SIZE); if (ret <= 0) break; ret = swap_write_page(handle, data_of(*snapshot), &bio); if (ret) break; if (!(nr_pages % m)) printk("\b\b\b\b%3d%%", nr_pages / m); nr_pages++; } err2 = hib_wait_on_bio_chain(&bio); do_gettimeofday(&stop); if (!ret) ret = err2; if (!ret) printk("\b\b\b\bdone\n"); else printk("\n"); swsusp_show_speed(&start, &stop, nr_to_write, "Wrote"); return ret; }
int swsusp_write(void) { struct swap_map_handle handle; struct snapshot_handle snapshot; struct swsusp_info *header; int error; if ((error = swsusp_swap_check())) { printk(KERN_ERR "swsusp: Cannot find swap device, try swapon -a.\n"); return error; } memset(&snapshot, 0, sizeof(struct snapshot_handle)); error = snapshot_read_next(&snapshot, PAGE_SIZE); if (error < PAGE_SIZE) return error < 0 ? error : -EFAULT; header = (struct swsusp_info *)data_of(snapshot); if (!enough_swap(header->pages)) { printk(KERN_ERR "swsusp: Not enough free swap\n"); return -ENOSPC; } error = get_swap_writer(&handle); if (!error) { unsigned long start = handle.cur_swap; error = swap_write_page(&handle, header); if (!error) error = save_image(&handle, &snapshot, header->pages - 1); if (!error) { flush_swap_writer(&handle); printk("S"); error = mark_swapfiles(swp_entry(root_swap, start)); printk("|\n"); } } if (error) free_all_swap_pages(root_swap, handle.bitmap); release_swap_writer(&handle); return error; }
void* gmi_analytic_data(struct gmi_model* m, struct gmi_ent* e) { struct gmi_analytic* m2 = to_model(m); return *(data_of(m2, agm_from_gmi(e))); }