text:
Homework Sheets
Dear St. Mary Magdalen Friends,
Please allow us to express our condoloences on the decision to close your beloved school. Should you be interested in seeing what St. Edward has to offer, we will be available to talk with you on Tuesday, January 19, at 6 p.m., in the SMM cafeteria. If you also would like a personal tour (after school hours, due to Covid precautions), please call us at (504) 888-6353.
School Masses--until further notice, attendance at school masses is limited to staff and students, although families of readers/soloists may attend. Because of spacing children more widely, there is very little space left.
Thank you for your understanding of the challenges we all are facing with this latest wave of Covid. Our staff is doing everything possible to keep as many students and staff in school as we can. The regulations continue to change and the decision trees have become more complex. Be assured that we are checking decisions with the Louisiana Department of Health.
Please be courteous to staff members who need to ask exposure questions or deliver news about quarantines.
Early Learning Center offered for PreK1-PreK4
--to schedule a Zoom Tour, click form for link.
LC Dress Down Day - Friday, January 14, 2022
Ida Disaster Relief (Catholic Charities)
Covid Precaution Update, including masks (November 3, 2021)
Food Shortages - Message from School Food & Nutrition
Schiro's-Schooltime Operations Update
Drop off and Pick up Instructions (video link)
Cafeteria Manager's Letter for 2021-22
School Lunch free for all--apply here
School Tool Box--link to order Fall School Supplies
2021-22 Immunization Notice
VIRTUAL OPEN HOUSE and tour
Celebration Plaza Brick Order Form
Incidentals (Pay for field trips, jerseys, club fees, etc.)
Incidentals Instructions
Free Access to Clarion Herald
Register and Pay for Ladies Council Events On-Line
Register and Pay for STEAM Events On-Line
Online Payments for School Lunches
NetSmartz - Internet Safety
Fun at St. Edward School 52 Photos
The schools of the Archdiocese of New Orleans, Louisiana, admit students of any race, color, national and ethnic origin and handicaps to all the rights, privileges, and activities generally accorded or made available to students at its schools. They do not discriminate on the basis of race, color, national and ethnic origin or handicaps in administration of their educational policies, admissions policies, scholarship and loan programs and athletic and other schooladministered programs.
Additionally, in compliance with Title IX of the Civil Rights Act of 1964, no persons in the school of the Archdiocese shall, on the basis of sex, be excluded from participation in, or be denied the benefits of, or be subjected to discrimination under any educational program or activity except as permitted under said Title IX.
THIS POLICY APPLIES TO ALL SCHOOLS WHICH ARE UNDER CATHOLIC ARCHDIOCESAN AUSPICES
website questions or comments
Jackie Sofio
jsofiosteddy.org


Festivals have more important role to play in today's modernized world where the space for joint or extended family is shrinking and nuclear families are becoming more and more common. The festivals allow us to come together, laugh, rejoice, and share a positive relationship. Happy individuals could lead to formation of a happy and prosperous society.
Food and Festival is what brings us together from times immemorial. Just as communities and people are inseparable from festivals, food has an equally important role to play in these occasions. It's hard to imagine these occasions without food.
We are now in that season of the year, when as a nation we will start celebrating different festivals in different parts of our country. The fascinating aspect of these festivals are the celebrations, decorations, fun, food, excitement and so much more that are part of these festivities. The days of festivities fills us with vibrancy and positive energy and I love being part of these festivals. With that thought, we will be starting our latest series, dedicated to Onam, one of the most important festival of the state of Kerala.
As part of this series, we will be sharing few interesting recipes which are particularly made for Sadhya. Besides these recipes our videos will be peppered with numerous anecdotes, facts related to Onam and Sadhya. My intention as a regional Indian Food Channel is to celebrate the true spirit of Indianness, which lies in its inclusiveness and accepting various cultures with its diversity. Even in this age of internet in which information is available readily on finger tips its amusing to know how little we know of each other's culture.
It has become all the more important in today's times to know about each other's culture and accept the diversity that has always been part of India since centuries.
We will be starting with our first video of this series about How to Make Coconut Milk. Coconut Milk is an important ingredient in Kerala Cuisine. There are many important dishes in which this ingredient is used-some sweet and some savory ones. Dishes like Fried Fish Curry, Palappams and Fish Mapas, Kadala Curry, Fish Molee, Potato Stew, Chicken/Mutton Stew, Mambazha Pulissery, Aviyal and plenty more.
Join us in Onam Celebrations by subscribing to our YouTube Channel. You can watch our video on How to make Coconut Milk and more Sadhya recipes on YouTube. Let us know your feedback by your comments below.
**Similarly, never use hot or warm water. Always use water kept at room temperature. Hot water brings out the oiliness of Coconut milk and may ruin its delicate flavor.
Please note that we are using double strain method. If you strain it just once, you may get some coconut particles in the coconut milk. Follow the Coconut to water ratio properly for getting such thick Coconut Milk.
Now, let's extract last and third extract of Coconut Milk. Transfer the Coconut from Muslin cloth to a grinder jar and add 2 Cups of Water and grind.


text:
April 19, 2012 Conflict resolution, Kurdish community, Kurdish Women, Political prisoners
Leyla Zana and MEP's visit hunger strikers in Strasbourg
In solidarity with the hundreds of political prisoners on hunger strike in Turkey, 15 Kurds from across Europe have been on a continuous hunger strike for 51 days to protest Abdullah Ocalan's isolation at Imrali prison. Having had visits from the BDP, letters of support from Nobel Peace Prize Laureates, and with an online signature campaign underway, the strikers were finally visited yesterday by 10 members of the European Parliament who joined Leyla Zana and South African Judge Essa Moosa to offer political support and highlight their cause.
Ms Zana also met with EP president Martin Schulz to discuss the Kurdish conflict, and participated in a press conference which you can watch in full below:
[youtube http://www.youtube.com/watch?v=hQKLP4ImPr4]
GUE/NGL Press release:
Cross-political group of MEPs express solidarity with Kurdish hunger strikers in Strasbourg
published by GUE/NGL Group in the EP on Thursday 19 Apr 2012
Drawing attention to the dramatic situation of fifteen Kurdish hunger strikers in Strasbourg, 10 Members of the European Parliament from various political groups today joined Sakharov Prize Laureate Leyla Zana, South African Judge Mr Essa Moosa and parliamentarians from several European countries in a visit of solidarity to the strikers.
Fifteen Kurds from several European countries have been on an indefinite hunger strike in Strasbourg's Saint Maurice Church since March 1st following a similar move by 400 political prisoners in Turkey in mid-February.
Today's visit by MEPs to lend humanitarian and political support to their cause highlights their plight and the disastrous consequences of Turkish policy towards Kurds.
The hunger strikers, whose physical condition is seriously deteriorating began this unprecedented action to protest against Turkish political repression of Kurds, to demand more political freedoms for Kurdish people in Turkey, the restart of negotiations for a political solution to the Kurdish issue in Turkey and the release of all political prisoners, including Abdullah Öcalan. They asked the MEPs, the EU and the Council of Europe to do their utmost to protect the Kurds' fundamental rights.
Earlier on, Leyla Zana met with European Parliament President Martin Schulz to discuss the situation of the Kurds. She also held discussions with EPP – Conservative, Socialist, Liberal, Green and Left political groups in the European Parliament and meets with the GUE/NGL group this evening.
The meetings with Members were followed by a European Parliament press conference in which Leyla Zana joined MEPs Jürgen Klute and Søren Søndergaard, hunger strikers and their supporting committee in calling for a political solution to the Kurdish question and for the hunger strike to end without any loss of life. Hunger striker Nigar Enayeti also spoke at the press conference, criticising the abuse by Turkey of Kurdish fundamental rights and highlighting the situation of Abdullah Öcalan who has been in Imrali's island prison for many years, in total isolation.
David Lundy +32 485 50 58 12
Sonja Giese (DE) +32 486 94 50 21
Tagged BDP, Europe, Hunger strikes, Leyla Zana, Ocalan, Protest, Turkey
IHRDC reports on 'acute persecution' of Kurdish activists in Iran
Protesters in London demand freedom for Ocalan

redpajama_set_name: RedPajamaCommonCrawl


text:
Q: Window Position on Startup Here's a question for me that really makes me wonder every time I start designing and developing a thick-client desktop application.
I'm a .NET developer, and with my forms (WinForms mostly, but the platform should be unimportant) I also choose the startup position to be Center.  The reason I do this is because I can't stand randomness, and as a user myself I don't like when windows jump all over my monitor.
So my question for you, is what is the best way to go about this?  Center an application startup window or have it randomly placed?  And why?

A: You can initially put it in the center, but I prefer it to stay where I left it. That's the easiest way to remember where things are. I don't consider this random. I don't see how center is less random than upper-left. They can both be seen as arbitrary.

A: What I like to do is save the last size and position of the application window (at app shutdown) as a user setting.  Then when the application is restarted I restore the last used size and position.
If you do this, be careful of using the spurious settings you'll get if the app is minimized at the time it is shut down (e.g. by a forced shutdown).
If I don't have a user setting to go by, I like to centre the window horizontally and then vertically I like it about 1/3 of the way down from the top.  This has a nicer feel to it than dead centre vertically.  Purely an asthetic choice on my part.

A: Did you think about allowing user to configure it? Maybe its the best approach, so each user could have a more satisfiying experience.
Give them options about where they would like windows to appear (upper/bottom right/left corner or center).

redpajama_set_name: RedPajamaStackExchange


text:
#define KMSG_COMPONENT "hypfs"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

#include <linux/types.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/namei.h>
#include <linux/vfs.h>
#include <linux/slab.h>
#include <linux/pagemap.h>
#include <linux/time.h>
#include <linux/parser.h>
#include <linux/sysfs.h>
#include <linux/module.h>
#include <linux/seq_file.h>
#include <linux/mount.h>
#include <linux/uio.h>
#include <asm/ebcdic.h>
#include "hypfs.h"

#define HYPFS_MAGIC 0x687970	/* ASCII 'hyp' */
#define TMP_SIZE 64		/* size of temporary buffers */

static struct dentry *hypfs_create_update_file(struct dentry *dir);

struct hypfs_sb_info {
	kuid_t uid;			/* uid used for files and dirs */
	kgid_t gid;			/* gid used for files and dirs */
	struct dentry *update_file;	/* file to trigger update */
	time_t last_update;		/* last update time in secs since 1970 */
	struct mutex lock;		/* lock to protect update process */
};

static const struct file_operations hypfs_file_ops;
static struct file_system_type hypfs_type;
static const struct super_operations hypfs_s_ops;

/* start of list of all dentries, which have to be deleted on update */
static struct dentry *hypfs_last_dentry;

static void hypfs_update_update(struct super_block *sb)
{
	struct hypfs_sb_info *sb_info = sb->s_fs_info;
	struct inode *inode = d_inode(sb_info->update_file);

	sb_info->last_update = get_seconds();
	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
}

/* directory tree removal functions */

static void hypfs_add_dentry(struct dentry *dentry)
{
	dentry->d_fsdata = hypfs_last_dentry;
	hypfs_last_dentry = dentry;
}

static void hypfs_remove(struct dentry *dentry)
{
	struct dentry *parent;

	parent = dentry->d_parent;
	inode_lock(d_inode(parent));
	if (simple_positive(dentry)) {
		if (d_is_dir(dentry))
			simple_rmdir(d_inode(parent), dentry);
		else
			simple_unlink(d_inode(parent), dentry);
	}
	d_delete(dentry);
	dput(dentry);
	inode_unlock(d_inode(parent));
}

static void hypfs_delete_tree(struct dentry *root)
{
	while (hypfs_last_dentry) {
		struct dentry *next_dentry;
		next_dentry = hypfs_last_dentry->d_fsdata;
		hypfs_remove(hypfs_last_dentry);
		hypfs_last_dentry = next_dentry;
	}
}

static struct inode *hypfs_make_inode(struct super_block *sb, umode_t mode)
{
	struct inode *ret = new_inode(sb);

	if (ret) {
		struct hypfs_sb_info *hypfs_info = sb->s_fs_info;
		ret->i_ino = get_next_ino();
		ret->i_mode = mode;
		ret->i_uid = hypfs_info->uid;
		ret->i_gid = hypfs_info->gid;
		ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME;
		if (S_ISDIR(mode))
			set_nlink(ret, 2);
	}
	return ret;
}

static void hypfs_evict_inode(struct inode *inode)
{
	clear_inode(inode);
	kfree(inode->i_private);
}

static int hypfs_open(struct inode *inode, struct file *filp)
{
	char *data = file_inode(filp)->i_private;
	struct hypfs_sb_info *fs_info;

	if (filp->f_mode & FMODE_WRITE) {
		if (!(inode->i_mode & S_IWUGO))
			return -EACCES;
	}
	if (filp->f_mode & FMODE_READ) {
		if (!(inode->i_mode & S_IRUGO))
			return -EACCES;
	}

	fs_info = inode->i_sb->s_fs_info;
	if(data) {
		mutex_lock(&fs_info->lock);
		filp->private_data = kstrdup(data, GFP_KERNEL);
		if (!filp->private_data) {
			mutex_unlock(&fs_info->lock);
			return -ENOMEM;
		}
		mutex_unlock(&fs_info->lock);
	}
	return nonseekable_open(inode, filp);
}

static ssize_t hypfs_read_iter(struct kiocb *iocb, struct iov_iter *to)
{
	struct file *file = iocb->ki_filp;
	char *data = file->private_data;
	size_t available = strlen(data);
	loff_t pos = iocb->ki_pos;
	size_t count;

	if (pos < 0)
		return -EINVAL;
	if (pos >= available || !iov_iter_count(to))
		return 0;
	count = copy_to_iter(data + pos, available - pos, to);
	if (!count)
		return -EFAULT;
	iocb->ki_pos = pos + count;
	file_accessed(file);
	return count;
}

static ssize_t hypfs_write_iter(struct kiocb *iocb, struct iov_iter *from)
{
	int rc;
	struct super_block *sb = file_inode(iocb->ki_filp)->i_sb;
	struct hypfs_sb_info *fs_info = sb->s_fs_info;
	size_t count = iov_iter_count(from);

	/*
	 * Currently we only allow one update per second for two reasons:
	 * 1. diag 204 is VERY expensive
	 * 2. If several processes do updates in parallel and then read the
	 *    hypfs data, the likelihood of collisions is reduced, if we restrict
	 *    the minimum update interval. A collision occurs, if during the
	 *    data gathering of one process another process triggers an update
	 *    If the first process wants to ensure consistent data, it has
	 *    to restart data collection in this case.
	 */
	mutex_lock(&fs_info->lock);
	if (fs_info->last_update == get_seconds()) {
		rc = -EBUSY;
		goto out;
	}
	hypfs_delete_tree(sb->s_root);
	if (MACHINE_IS_VM)
		rc = hypfs_vm_create_files(sb->s_root);
	else
		rc = hypfs_diag_create_files(sb->s_root);
	if (rc) {
		pr_err("Updating the hypfs tree failed\n");
		hypfs_delete_tree(sb->s_root);
		goto out;
	}
	hypfs_update_update(sb);
	rc = count;
	iov_iter_advance(from, count);
out:
	mutex_unlock(&fs_info->lock);
	return rc;
}

static int hypfs_release(struct inode *inode, struct file *filp)
{
	kfree(filp->private_data);
	return 0;
}

enum { opt_uid, opt_gid, opt_err };

static const match_table_t hypfs_tokens = {
	{opt_uid, "uid=%u"},
	{opt_gid, "gid=%u"},
	{opt_err, NULL}
};

static int hypfs_parse_options(char *options, struct super_block *sb)
{
	char *str;
	substring_t args[MAX_OPT_ARGS];
	kuid_t uid;
	kgid_t gid;

	if (!options)
		return 0;
	while ((str = strsep(&options, ",")) != NULL) {
		int token, option;
		struct hypfs_sb_info *hypfs_info = sb->s_fs_info;

		if (!*str)
			continue;
		token = match_token(str, hypfs_tokens, args);
		switch (token) {
		case opt_uid:
			if (match_int(&args[0], &option))
				return -EINVAL;
			uid = make_kuid(current_user_ns(), option);
			if (!uid_valid(uid))
				return -EINVAL;
			hypfs_info->uid = uid;
			break;
		case opt_gid:
			if (match_int(&args[0], &option))
				return -EINVAL;
			gid = make_kgid(current_user_ns(), option);
			if (!gid_valid(gid))
				return -EINVAL;
			hypfs_info->gid = gid;
			break;
		case opt_err:
		default:
			pr_err("%s is not a valid mount option\n", str);
			return -EINVAL;
		}
	}
	return 0;
}

static int hypfs_show_options(struct seq_file *s, struct dentry *root)
{
	struct hypfs_sb_info *hypfs_info = root->d_sb->s_fs_info;

	seq_printf(s, ",uid=%u", from_kuid_munged(&init_user_ns, hypfs_info->uid));
	seq_printf(s, ",gid=%u", from_kgid_munged(&init_user_ns, hypfs_info->gid));
	return 0;
}

static int hypfs_fill_super(struct super_block *sb, void *data, int silent)
{
	struct inode *root_inode;
	struct dentry *root_dentry;
	int rc = 0;
	struct hypfs_sb_info *sbi;

	sbi = kzalloc(sizeof(struct hypfs_sb_info), GFP_KERNEL);
	if (!sbi)
		return -ENOMEM;
	mutex_init(&sbi->lock);
	sbi->uid = current_uid();
	sbi->gid = current_gid();
	sb->s_fs_info = sbi;
	sb->s_blocksize = PAGE_CACHE_SIZE;
	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	sb->s_magic = HYPFS_MAGIC;
	sb->s_op = &hypfs_s_ops;
	if (hypfs_parse_options(data, sb))
		return -EINVAL;
	root_inode = hypfs_make_inode(sb, S_IFDIR | 0755);
	if (!root_inode)
		return -ENOMEM;
	root_inode->i_op = &simple_dir_inode_operations;
	root_inode->i_fop = &simple_dir_operations;
	sb->s_root = root_dentry = d_make_root(root_inode);
	if (!root_dentry)
		return -ENOMEM;
	if (MACHINE_IS_VM)
		rc = hypfs_vm_create_files(root_dentry);
	else
		rc = hypfs_diag_create_files(root_dentry);
	if (rc)
		return rc;
	sbi->update_file = hypfs_create_update_file(root_dentry);
	if (IS_ERR(sbi->update_file))
		return PTR_ERR(sbi->update_file);
	hypfs_update_update(sb);
	pr_info("Hypervisor filesystem mounted\n");
	return 0;
}

static struct dentry *hypfs_mount(struct file_system_type *fst, int flags,
			const char *devname, void *data)
{
	return mount_single(fst, flags, data, hypfs_fill_super);
}

static void hypfs_kill_super(struct super_block *sb)
{
	struct hypfs_sb_info *sb_info = sb->s_fs_info;

	if (sb->s_root)
		hypfs_delete_tree(sb->s_root);
	if (sb_info->update_file)
		hypfs_remove(sb_info->update_file);
	kfree(sb->s_fs_info);
	sb->s_fs_info = NULL;
	kill_litter_super(sb);
}

static struct dentry *hypfs_create_file(struct dentry *parent, const char *name,
					char *data, umode_t mode)
{
	struct dentry *dentry;
	struct inode *inode;

	inode_lock(d_inode(parent));
	dentry = lookup_one_len(name, parent, strlen(name));
	if (IS_ERR(dentry)) {
		dentry = ERR_PTR(-ENOMEM);
		goto fail;
	}
	inode = hypfs_make_inode(parent->d_sb, mode);
	if (!inode) {
		dput(dentry);
		dentry = ERR_PTR(-ENOMEM);
		goto fail;
	}
	if (S_ISREG(mode)) {
		inode->i_fop = &hypfs_file_ops;
		if (data)
			inode->i_size = strlen(data);
		else
			inode->i_size = 0;
	} else if (S_ISDIR(mode)) {
		inode->i_op = &simple_dir_inode_operations;
		inode->i_fop = &simple_dir_operations;
		inc_nlink(d_inode(parent));
	} else
		BUG();
	inode->i_private = data;
	d_instantiate(dentry, inode);
	dget(dentry);
fail:
	inode_unlock(d_inode(parent));
	return dentry;
}

struct dentry *hypfs_mkdir(struct dentry *parent, const char *name)
{
	struct dentry *dentry;

	dentry = hypfs_create_file(parent, name, NULL, S_IFDIR | DIR_MODE);
	if (IS_ERR(dentry))
		return dentry;
	hypfs_add_dentry(dentry);
	return dentry;
}

static struct dentry *hypfs_create_update_file(struct dentry *dir)
{
	struct dentry *dentry;

	dentry = hypfs_create_file(dir, "update", NULL,
				   S_IFREG | UPDATE_FILE_MODE);
	/*
	 * We do not put the update file on the 'delete' list with
	 * hypfs_add_dentry(), since it should not be removed when the tree
	 * is updated.
	 */
	return dentry;
}

struct dentry *hypfs_create_u64(struct dentry *dir,
				const char *name, __u64 value)
{
	char *buffer;
	char tmp[TMP_SIZE];
	struct dentry *dentry;

	snprintf(tmp, TMP_SIZE, "%llu\n", (unsigned long long int)value);
	buffer = kstrdup(tmp, GFP_KERNEL);
	if (!buffer)
		return ERR_PTR(-ENOMEM);
	dentry =
	    hypfs_create_file(dir, name, buffer, S_IFREG | REG_FILE_MODE);
	if (IS_ERR(dentry)) {
		kfree(buffer);
		return ERR_PTR(-ENOMEM);
	}
	hypfs_add_dentry(dentry);
	return dentry;
}

struct dentry *hypfs_create_str(struct dentry *dir,
				const char *name, char *string)
{
	char *buffer;
	struct dentry *dentry;

	buffer = kmalloc(strlen(string) + 2, GFP_KERNEL);
	if (!buffer)
		return ERR_PTR(-ENOMEM);
	sprintf(buffer, "%s\n", string);
	dentry =
	    hypfs_create_file(dir, name, buffer, S_IFREG | REG_FILE_MODE);
	if (IS_ERR(dentry)) {
		kfree(buffer);
		return ERR_PTR(-ENOMEM);
	}
	hypfs_add_dentry(dentry);
	return dentry;
}

static const struct file_operations hypfs_file_ops = {
	.open		= hypfs_open,
	.release	= hypfs_release,
	.read_iter	= hypfs_read_iter,
	.write_iter	= hypfs_write_iter,
	.llseek		= no_llseek,
};

static struct file_system_type hypfs_type = {
	.owner		= THIS_MODULE,
	.name		= "s390_hypfs",
	.mount		= hypfs_mount,
	.kill_sb	= hypfs_kill_super
};
MODULE_ALIAS_FS("s390_hypfs");

static const struct super_operations hypfs_s_ops = {
	.statfs		= simple_statfs,
	.evict_inode	= hypfs_evict_inode,
	.show_options	= hypfs_show_options,
};

static int __init hypfs_init(void)
{
	int rc;

	rc = hypfs_dbfs_init();
	if (rc)
		return rc;
	if (hypfs_diag_init()) {
		rc = -ENODATA;
		goto fail_dbfs_exit;
	}
	if (hypfs_vm_init()) {
		rc = -ENODATA;
		goto fail_hypfs_diag_exit;
	}
	if (hypfs_sprp_init()) {
		rc = -ENODATA;
		goto fail_hypfs_vm_exit;
	}
	if (hypfs_diag0c_init()) {
		rc = -ENODATA;
		goto fail_hypfs_sprp_exit;
	}
	rc = sysfs_create_mount_point(hypervisor_kobj, "s390");
	if (rc)
		goto fail_hypfs_diag0c_exit;
	rc = register_filesystem(&hypfs_type);
	if (rc)
		goto fail_filesystem;
	return 0;

fail_filesystem:
	sysfs_remove_mount_point(hypervisor_kobj, "s390");
fail_hypfs_diag0c_exit:
	hypfs_diag0c_exit();
fail_hypfs_sprp_exit:
	hypfs_sprp_exit();
fail_hypfs_vm_exit:
	hypfs_vm_exit();
fail_hypfs_diag_exit:
	hypfs_diag_exit();
fail_dbfs_exit:
	hypfs_dbfs_exit();
	pr_err("Initialization of hypfs failed with rc=%i\n", rc);
	return rc;
}

static void __exit hypfs_exit(void)
{
	unregister_filesystem(&hypfs_type);
	sysfs_remove_mount_point(hypervisor_kobj, "s390");
	hypfs_diag0c_exit();
	hypfs_sprp_exit();
	hypfs_vm_exit();
	hypfs_diag_exit();
	hypfs_dbfs_exit();
}

module_init(hypfs_init)
module_exit(hypfs_exit)

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Michael Holzheu <holzheu@de.ibm.com>");
MODULE_DESCRIPTION("s390 Hypervisor Filesystem");

redpajama_set_name: RedPajamaGithub


text:
Suspect Behind Leak of Kim Darroch's Classified Cables Identified by UK Police - Reports
© AFP 2019 / ALEX WONG
https://sputniknews.com/europe/201907141076239516-suspect-kim-darroch-classified-cables-identified-uk-police/
MOSCOW (Sputnik) - The suspect behind the leak of confidential memos penned by former UK ambassador in Washington Kim Darroch last week has been identified, yet not named by UK police, local media reported on Sunday.
On Friday, the UK Metropolitan Police opened a probe into the leak of excerpts from confidential cables that Darroch had sent to London in which he described the White House as "uniquely dysfunctional" and warned that Trump could end up in "disgrace." Darroch also described Trump as inept, insecure and incompetent.
"They think they know who did the leaking. It's now a case of building a case that will stand up in court. It was someone with access to historical files. They went in and grabbed a range of material. It was quite crude," an unnamed government source told the Sunday Times newspaper.
According to the report, the police ruled out the possibility of the leak resulting from a foreign state-sponsored hacking attack on a government computer.
On Friday, Assistant Commissioner Neil Basu said a counter-terrorism unit responsible for investigating claims of breaches of the Official Secrets Act would lead the probe into the suspected leak. Basu urged those behind the cables' publication to spare police the effort and turn themselves in. He said those who had any information should come forward.
On July 6, the Daily Mail newspaper published excerpts from Darroch's confidential memos in which he speaks critically of the US government. The envoy resigned on Wednesday, a day after Trump in a tweet called him "a very stupid guy." According to media reports, Darroch quit because Boris Johnson, the former foreign secretary and the front-runner to succeed Theresa May as prime minister, refused to back him during a Conservative leadership TV debate.
UK Police Launch Investigation in Ambassador Kim Darroch's Leaked Emails
Are Kim Darroch's Trump Leaks Just a 'Subordinate Taking Revenge For Years of Bullying'?
Kim Darroch: UK May Become 'Police State', MPs Warn as Police Tell Media Not to Print Leaked Cables
police, Kim Darroch, Donald Trump, USA, UK


text:
The 100 3×09 Stealing Fire preview
Warner Bros International, Inc
Kane (Henry Ian Cusick) and Pike (Michael Beach) continued their power struggle on the latest episode of The 100.
Pike suspected that there may be a leak within Arkadia and asked Bellamy (Bob Morley) and Monty (Christopher Larkin) to spy on their friends and find out where the leak was coming from. Kane attempted to find a peaceful way to handle things but when he orchestrated an breakout from the Arkadia prison, Pike sentenced him to death.
Elsewhere Raven (Lindsey Morgan) was convinced by A.L.I.E. (Erica Cerra) to reach out to Jasper (Devon Bostick) for help when she needed a password of Monty's. When they started talking about Finn (Thomas McDonell), she realised that her memories had gone and decided to fight back against A.L.I.E.
The next episode of the season is Stealing Fire. Clarke (Eliza Taylor) discovers a shocking truth. Octavia (Marie Avgeropoulos) has to make a big decision that could have devastating consequences. Kane and Abby (Paige Turco) share a moment.
Arrow Video FrightFest 2018: Lasso review
Pip Ellwood-Hughes August 26, 2018
Beyond Skyline sequel trailer released starring Frank Grillo
Jason Palmer October 2, 2017
10 things we want from The 100 season 4
Gay Focus News
We've got a crush on The 100 & Black Sails star Zach McGowan
The 100 3×16 Perverse Instantiation Part 2 preview
The 100 3×14 Red Sky at Morning preview
The 100 3×13 Join or Die preview


The following e-book will help you with managing multi-cloud backup and security. Read it here to learn everything you need to know about securing a multi-cloud deployment, multi-cloud management must-haves, and more.
One reason companies are putting information on cloud services is apps are there, and where apps go data follows. That and more in this 'Storage' magazine issue.
Learn when to move data or compute to overcome the performance bottleneck. In this issue, we also look at emerging technologies jockeying to replace NAND flash.
In this issue, we look at vSphere vs. KVM, along with other hyper-converged hypervisors. We also check out how snapshots and replication complement traditional backup.
How do you know if multi-cloud storage is right for you? In this handbook from the editors at searchStorage.com, learn what differentiates multi-cloud from hybrid cloud, 4 problems that a multi-cloud strategy can solve, and more.
In this issue, we discuss what you need know when adopting NVMe flash storage. Additionally, we take a look at how to deal with the cost and data management issues of all-flash data centers.
The need to protect data in container applications has emerged with the advent of persistent data in containers. In this 'Storage' magazine issue, we also look at how object storage can thwart ransomware attacks.
'Storage' magazine looks at how the intense competition among all-flash array vendors is affecting the AFA market. And our annual IT Priorities Survey reveals storage spending trends you need to know about for 2018.
'Storage' magazine examines the best ways to manage various types of unstructured data and maximize its use on a global scale. We also look at how application-centric storage is changing the storage market.
It's important for IT buyers and administrators to understand NAND flash technology. Layers, bits per cell and durability are all concerns.
'Storage' magazine examines nonvolatile memory express and the future of flash storage. We also look at combating ransomware and intellectual property theft.
Storage magazine reveals the winners of its annual enterprise storage systems Products of the Year competition. Also get ready for the EU's GDPR requirements.
Storage magazine examines 2018 storage startup trends and eight vendors to watch. And we look at the state of software-defined storage and storage-class memory.
This edition of Storage Magazine provides an opportunity to look back at the hottest data storage technologies predicted for 2018—including predictive storage analytics, converged secondary storage, and multicloud—to see if they made the anticipated impact. Downloading your copy now.
In this handbook, learn 3 reasons to adopt the multicloud for data protection and backup purposes. Then, find out about some tools to help you optimize, automate, and secure your multicloud management.
'Storage' magazine examines how to screen disaster recovery-as-a-service providers, as well as evolving cold data storage and file sync-and-share offerings.
Hyper-converged computing updates your old data center with software that defines hardware. You can do-it-yourself, but it is not easy. This e-guide will discuss the pros and cons of taking a DIY approach, get you started in the process to building your own hyper-converged infrastructure, and more.
'Storage' magazine examines the Dell EMC acquisition, as well as how multicloud storage mitigates vendor lock-in and new open source storage options.
'Storage' magazine looks at where persistent data storage for containerized applications is headed, as well as NVMeover Fabrics and copy data management.
'Storage' magazine looks at the advantages of disaggregation and resource pool management as well as hybrid cloud storage and the best use of flash.
This issue of 'Storage' magazine looks at the various storage options hyper-converged infrastructure vendors offer in their latest appliances.
Use this handbook to learn more about where NVMe development began, and predict where it's heading in the future, including how it will improve any form of nonvolatile memory, improve Ethernet connections, and more.


BlueEdu is two-year EU Erasmus+ Sector Skills Alliance project led by the Norwegian University of Science and Technology (NTNU), Trondheim. Other partners are The Federation of European Aquaculture Producers (FEAP), The University of Stirling (UK), Guri Kunna VET School (Norway), Pisces Learning Innovations Ltd (UK), and Aquark (Greece).
The overall goal is to identify skills gaps within the European aquaculture workforce, evaluate education and training demand and supply, and establish industry and education and training providers' receptiveness to innovative delivery methods. It will specifically focus on marine cage based rearing systems and technology across 12 partner countries that face many of the same skills development challenges, irrespective of the different fish species farmed in northern and southern Europe.
The outcomes of the analysis will be disseminated to stakeholders, supported by a proposed action plan for future 'aquaculture VET Innovation and the harmonisation of qualifications', catalysing a new Strategic Alliance between northern and southern European aquaculture interests and their VET sector.
John Bostock of the Sustainable Aquaculture Research Group in Stirling is leading the workpackage "Analysis and investigations of existing studies and research based data on skills gaps in aquaculture industry and VET supply."